/*
    Copyright(c) 2011 Sencha Inc.
    licensing@sencha.com
    http://www.sencha.com/touchlicense
 */
if (typeof Ext === "undefined") {
    Ext = {}
}
Ext.apply = (function() {
    for ( var a in {
        valueOf : 1
    }) {
        return function(c, b, e) {
            if (e) {
                Ext.apply(c, e)
            }
            if (c && b && typeof b === "object") {
                for ( var d in b) {
                    c[d] = b[d]
                }
            }
            return c
        }
    }
    return function(c, b, e) {
        if (e) {
            Ext.apply(c, e)
        }
        if (c && b && typeof b === "object") {
            for ( var d in b) {
                c[d] = b[d]
            }
            if (b.toString !== Object.prototype.toString) {
                c.toString = b.toString
            }
            if (b.valueOf !== Object.prototype.valueOf) {
                c.valueOf = b.valueOf
            }
        }
        return c
    }
})();
Ext
        .apply(
                Ext,
                {
                    platformVersion : "1.0",
                    platformVersionDetail : {
                        major : 1,
                        minor : 0,
                        patch : 3
                    },
                    userAgent : navigator.userAgent.toLowerCase(),
                    cache : {},
                    idSeed : 1000,
                    BLANK_IMAGE_URL : "",
                    isStrict : document.compatMode == "CSS1Compat",
                    windowId : "ext-window",
                    documentId : "ext-document",
                    emptyFn : function() {
                    },
                    isSecure : /^https/i.test(window.location.protocol),
                    isReady : false,
                    enableGarbageCollector : true,
                    enableListenerCollection : true,
                    applyIf : function(b, a) {
                        var c, d;
                        if (b) {
                            for (c in a) {
                                if (b[c] === d) {
                                    b[c] = a[c]
                                }
                            }
                        }
                        return b
                    },
                    repaint : function() {
                        var a = Ext.getBody().createChild({
                            cls : "x-mask x-mask-transparent"
                        });
                        setTimeout(function() {
                            a.remove()
                        }, 0)
                    },
                    id : function(a, b) {
                        a = Ext.getDom(a) || {};
                        if (a === document) {
                            a.id = this.documentId
                        } else {
                            if (a === window) {
                                a.id = this.windowId
                            }
                        }
                        a.id = a.id || ((b || "ext-gen") + (++Ext.idSeed));
                        return a.id
                    },
                    extend : function() {
                        var b = function(d) {
                            for ( var c in d) {
                                if (!d.hasOwnProperty(c)) {
                                    continue
                                }
                                this[c] = d[c]
                            }
                        };
                        var a = Object.prototype.constructor;
                        return function(c, h, f) {
                            if (Ext.isObject(h)) {
                                f = h;
                                h = c;
                                c = f.constructor != a ? f.constructor
                                        : function() {
                                            h.apply(this, arguments)
                                        }
                            }
                            if (!h) {
                                throw "Attempting to extend from a class which has not been loaded on the page."
                            }
                            var e = function() {
                            }, d, g = h.prototype;
                            e.prototype = g;
                            d = c.prototype = new e();
                            d.constructor = c;
                            c.superclass = g;
                            if (g.constructor == a) {
                                g.constructor = h
                            }
                            c.override = function(i) {
                                Ext.override(c, i)
                            };
                            d.superclass = d.supr = (function() {
                                return g
                            });
                            d.override = b;
                            d.proto = d;
                            c.override(f);
                            c.extend = function(i) {
                                return Ext.extend(c, i)
                            };
                            return c
                        }
                    }(),
                    override : function(a, b) {
                        Ext.apply(a.prototype, b)
                    },
                    namespace : function() {
                        var e = arguments.length, d, f, c, a, h, g, b;
                        for (d = 0; d < e; d++) {
                            f = arguments[d];
                            g = f.split(".");
                            if (window.Ext) {
                                b = window[g[0]] = Object(window[g[0]])
                            } else {
                                b = arguments.callee.caller.arguments[0]
                            }
                            for (a = 1, h = g.length; a < h; a++) {
                                b = b[g[a]] = Object(b[g[a]])
                            }
                        }
                        return b
                    },
                    urlEncode : function(f, d) {
                        var b, a = [], c = encodeURIComponent;
                        Ext
                                .iterate(
                                        f,
                                        function(e, g) {
                                            b = Ext.isEmpty(g);
                                            Ext
                                                    .each(
                                                            b ? e : g,
                                                            function(h) {
                                                                a
                                                                        .push(
                                                                                "&",
                                                                                c(e),
                                                                                "=",
                                                                                (!Ext
                                                                                        .isEmpty(h) && (h != e || !b)) ? (Ext
                                                                                        .isDate(h) ? Ext
                                                                                        .encode(
                                                                                                h)
                                                                                        .replace(
                                                                                                /"/g,
                                                                                                "")
                                                                                        : c(h))
                                                                                        : "")
                                                            })
                                        });
                        if (!d) {
                            a.shift();
                            d = ""
                        }
                        return d + a.join("")
                    },
                    urlDecode : function(c, b) {
                        if (Ext.isEmpty(c)) {
                            return {}
                        }
                        var g = {}, f = c.split("&"), h = decodeURIComponent, a, e;
                        Ext.each(f, function(d) {
                            d = d.split("=");
                            a = h(d[0]);
                            e = h(d[1]);
                            g[a] = b || !g[a] ? e : [].concat(g[a]).concat(e)
                        });
                        return g
                    },
                    htmlEncode : function(a) {
                        return Ext.util.Format.htmlEncode(a)
                    },
                    htmlDecode : function(a) {
                        return Ext.util.Format.htmlDecode(a)
                    },
                    urlAppend : function(a, b) {
                        if (!Ext.isEmpty(b)) {
                            return a + (a.indexOf("?") === -1 ? "?" : "&") + b
                        }
                        return a
                    },
                    toArray : function(c, b, a) {
                        return Array.prototype.slice.call(c, b || 0, a
                                || c.length)
                    },
                    each : function(e, d, c) {
                        if (Ext.isEmpty(e, true)) {
                            return 0
                        }
                        if (!Ext.isIterable(e) || Ext.isPrimitive(e)) {
                            e = [ e ]
                        }
                        for ( var b = 0, a = e.length; b < a; b++) {
                            if (d.call(c || e[b], e[b], b, e) === false) {
                                return b
                            }
                        }
                        return true
                    },
                    iterate : function(c, b, a) {
                        if (Ext.isEmpty(c)) {
                            return
                        }
                        if (Ext.isIterable(c)) {
                            Ext.each(c, b, a);
                            return
                        } else {
                            if (Ext.isObject(c)) {
                                for ( var d in c) {
                                    if (c.hasOwnProperty(d)) {
                                        if (b.call(a || c, d, c[d], c) === false) {
                                            return
                                        }
                                    }
                                }
                            }
                        }
                    },
                    pluck : function(a, c) {
                        var b = [];
                        Ext.each(a, function(d) {
                            b.push(d[c])
                        });
                        return b
                    },
                    getBody : function() {
                        return Ext.get(document.body || false)
                    },
                    getHead : function() {
                        var a;
                        return function() {
                            if (a == undefined) {
                                a = Ext
                                        .get(DOC.getElementsByTagName("head")[0])
                            }
                            return a
                        }
                    }(),
                    getDoc : function() {
                        return Ext.get(document)
                    },
                    getCmp : function(a) {
                        return Ext.ComponentMgr.get(a)
                    },
                    getOrientation : function() {
                        return window.innerHeight > window.innerWidth ? "portrait"
                                : "landscape"
                    },
                    isIterable : function(a) {
                        if (!a) {
                            return false
                        }
                        if (Ext.isArray(a) || a.callee) {
                            return true
                        }
                        if (/NodeList|HTMLCollection/
                                .test(Object.prototype.toString.call(a))) {
                            return true
                        }
                        return ((typeof a.nextNode != "undefined" || a.item) && Ext
                                .isNumber(a.length)) || false
                    },
                    num : function(b, a) {
                        b = Number(Ext.isEmpty(b)
                                || Ext.isArray(b)
                                || typeof b == "boolean"
                                || (typeof b == "string" && Ext.util.Format
                                        .trim(b).length == 0) ? NaN : b);
                        return isNaN(b) ? a : b
                    },
                    isEmpty : function(d, a) {
                        var b = d == null, c = (Ext.isArray(d) && !d.length), e = !a ? d === ""
                                : false;
                        return b || c || e
                    },
                    isArray : function(a) {
                        return Object.prototype.toString.apply(a) === "[object Array]"
                    },
                    isDate : function(a) {
                        return Object.prototype.toString.apply(a) === "[object Date]"
                    },
                    isObject : function(a) {
                        return !!a
                                && !a.tagName
                                && Object.prototype.toString.call(a) === "[object Object]"
                    },
                    isPrimitive : function(a) {
                        return Ext.isString(a) || Ext.isNumber(a)
                                || Ext.isBoolean(a)
                    },
                    isFunction : function(a) {
                        return Object.prototype.toString.apply(a) === "[object Function]"
                    },
                    isNumber : function(a) {
                        return Object.prototype.toString.apply(a) === "[object Number]"
                                && isFinite(a)
                    },
                    isString : function(a) {
                        return typeof a === "string"
                    },
                    isBoolean : function(a) {
                        return Object.prototype.toString.apply(a) === "[object Boolean]"
                    },
                    isElement : function(a) {
                        return a ? !!a.tagName : false
                    },
                    isDefined : function(a) {
                        return typeof a !== "undefined"
                    },
                    destroy : function() {
                        var c = arguments.length, b, a;
                        for (b = 0; b < c; b++) {
                            a = arguments[b];
                            if (a) {
                                if (Ext.isArray(a)) {
                                    this.destroy.apply(this, a)
                                } else {
                                    if (Ext.isFunction(a.destroy)) {
                                        a.destroy()
                                    } else {
                                        if (a.dom) {
                                            a.remove()
                                        }
                                    }
                                }
                            }
                        }
                    }
                });
Ext.SSL_SECURE_URL = Ext.isSecure && "about:blank";
Ext.ns = Ext.namespace;
Ext.ns("Ext.util", "Ext.data", "Ext.list", "Ext.form", "Ext.menu", "Ext.state",
        "Ext.layout", "Ext.app", "Ext.ux", "Ext.plugins", "Ext.direct",
        "Ext.lib", "Ext.gesture");
Ext.util.Observable = Ext
        .extend(
                Object,
                {
                    isObservable : true,
                    constructor : function(a) {
                        var b = this;
                        Ext.apply(b, a);
                        if (b.listeners) {
                            b.on(b.listeners);
                            delete b.listeners
                        }
                        b.events = b.events || {};
                        if (this.bubbleEvents) {
                            this.enableBubble(this.bubbleEvents)
                        }
                    },
                    eventOptionsRe : /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|element|vertical|horizontal)$/,
                    addManagedListener : function(h, d, f, e, c) {
                        var g = this, a = g.managedListeners = g.managedListeners
                                || [], b;
                        if (Ext.isObject(d)) {
                            c = d;
                            for (d in c) {
                                if (!c.hasOwnProperty(d)) {
                                    continue
                                }
                                b = c[d];
                                if (!g.eventOptionsRe.test(d)) {
                                    g.addManagedListener(h, d, b.fn || b,
                                            b.scope || c.scope, b.fn ? b : c)
                                }
                            }
                        } else {
                            a.push({
                                item : h,
                                ename : d,
                                fn : f,
                                scope : e,
                                options : c
                            });
                            h.on(d, f, e, c)
                        }
                    },
                    removeManagedListener : function(k, e, h, l) {
                        var g = this, b, d, j, c, a, f;
                        if (Ext.isObject(e)) {
                            b = e;
                            for (e in b) {
                                if (!b.hasOwnProperty(e)) {
                                    continue
                                }
                                d = b[e];
                                if (!g.eventOptionsRe.test(e)) {
                                    g.removeManagedListener(k, e, d.fn || d,
                                            d.scope || b.scope)
                                }
                            }
                        }
                        j = this.managedListeners ? this.managedListeners
                                .slice() : [];
                        a = j.length;
                        for (f = 0; f < a; f++) {
                            c = j[f];
                            if (c.item === k && c.ename === e
                                    && (!h || c.fn === h)
                                    && (!l || c.scope === l)) {
                                this.managedListeners.remove(c);
                                k.un(c.ename, c.fn, c.scope)
                            }
                        }
                    },
                    fireEvent : function() {
                        var h = this, c = Ext.toArray(arguments), e = c[0]
                                .toLowerCase(), d = true, g = h.events[e], b = h.eventQueue, f;
                        if (h.eventsSuspended === true) {
                            if (b) {
                                b.push(c)
                            }
                            return false
                        } else {
                            if (g && Ext.isObject(g) && g.bubble) {
                                if (g.fire.apply(g, c.slice(1)) === false) {
                                    return false
                                }
                                f = h.getBubbleTarget && h.getBubbleTarget();
                                if (f && f.isObservable) {
                                    if (!f.events[e]
                                            || !Ext.isObject(f.events[e])
                                            || !f.events[e].bubble) {
                                        f.enableBubble(e)
                                    }
                                    return f.fireEvent.apply(f, c)
                                }
                            } else {
                                if (g && Ext.isObject(g)) {
                                    c.shift();
                                    d = g.fire.apply(g, c)
                                }
                            }
                        }
                        return d
                    },
                    addListener : function(b, d, c, g) {
                        var f = this, a, e;
                        if (Ext.isObject(b)) {
                            g = b;
                            for (b in g) {
                                if (!g.hasOwnProperty(b)) {
                                    continue
                                }
                                a = g[b];
                                if (!f.eventOptionsRe.test(b)) {
                                    f.addListener(b, a.fn || a, a.scope
                                            || g.scope, a.fn ? a : g)
                                }
                            }
                        } else {
                            b = b.toLowerCase();
                            f.events[b] = f.events[b] || true;
                            e = f.events[b] || true;
                            if (Ext.isBoolean(e)) {
                                f.events[b] = e = new Ext.util.Event(f, b)
                            }
                            e.addListener(d, c, Ext.isObject(g) ? g : {})
                        }
                    },
                    removeListener : function(b, d, c) {
                        var f = this, a, e;
                        if (Ext.isObject(b)) {
                            var g = b;
                            for (b in g) {
                                if (!g.hasOwnProperty(b)) {
                                    continue
                                }
                                a = g[b];
                                if (!f.eventOptionsRe.test(b)) {
                                    f.removeListener(b, a.fn || a, a.scope
                                            || g.scope)
                                }
                            }
                        } else {
                            b = b.toLowerCase();
                            e = f.events[b];
                            if (e.isEvent) {
                                e.removeListener(d, c)
                            }
                        }
                    },
                    clearListeners : function() {
                        var b = this.events, c, a;
                        for (a in b) {
                            if (!b.hasOwnProperty(a)) {
                                continue
                            }
                            c = b[a];
                            if (c.isEvent) {
                                c.clearListeners()
                            }
                        }
                        this.clearManagedListeners()
                    },
                    purgeListeners : function() {
                        console
                                .warn("MixedCollection: purgeListeners has been deprecated. Please use clearListeners.");
                        return this.clearListeners.apply(this, arguments)
                    },
                    clearManagedListeners : function() {
                        var b = this.managedListeners || [], d = b.length, c, a;
                        for (c = 0; c < d; c++) {
                            a = b[c];
                            a.item.un(a.ename, a.fn, a.scope)
                        }
                        this.managedListener = []
                    },
                    purgeManagedListeners : function() {
                        console
                                .warn("MixedCollection: purgeManagedListeners has been deprecated. Please use clearManagedListeners.");
                        return this.clearManagedListeners
                                .apply(this, arguments)
                    },
                    addEvents : function(e) {
                        var d = this;
                        d.events = d.events || {};
                        if (Ext.isString(e)) {
                            var b = arguments, c = b.length;
                            while (c--) {
                                d.events[b[c]] = d.events[b[c]] || true
                            }
                        } else {
                            Ext.applyIf(d.events, e)
                        }
                    },
                    hasListener : function(a) {
                        var b = this.events[a];
                        return b.isEvent === true && b.listeners.length > 0
                    },
                    suspendEvents : function(a) {
                        this.eventsSuspended = true;
                        if (a && !this.eventQueue) {
                            this.eventQueue = []
                        }
                    },
                    resumeEvents : function() {
                        var a = this, b = a.eventQueue || [];
                        a.eventsSuspended = false;
                        delete a.eventQueue;
                        Ext.each(b, function(c) {
                            a.fireEvent.apply(a, c)
                        })
                    },
                    relayEvents : function(b, e, h) {
                        h = h || "";
                        var g = this, a = e.length, d, c;
                        function f(i) {
                            return function() {
                                return g.fireEvent.apply(g, [ h + i ]
                                        .concat(Array.prototype.slice.call(
                                                arguments, 0, -1)))
                            }
                        }
                        for (d = 0, a = e.length; d < a; d++) {
                            c = e[d].substr(h.length);
                            g.events[c] = g.events[c] || true;
                            b.on(c, f(c), g)
                        }
                    },
                    enableBubble : function(a) {
                        var b = this;
                        if (!Ext.isEmpty(a)) {
                            a = Ext.isArray(a) ? a : Ext.toArray(arguments);
                            Ext.each(a, function(c) {
                                c = c.toLowerCase();
                                var d = b.events[c] || true;
                                if (Ext.isBoolean(d)) {
                                    d = new Ext.util.Event(b, c);
                                    b.events[c] = d
                                }
                                d.bubble = true
                            })
                        }
                    }
                });
Ext.override(Ext.util.Observable, {
    on : Ext.util.Observable.prototype.addListener,
    un : Ext.util.Observable.prototype.removeListener,
    mon : Ext.util.Observable.prototype.addManagedListener,
    mun : Ext.util.Observable.prototype.removeManagedListener
});
Ext.util.Observable.releaseCapture = function(a) {
    a.fireEvent = Ext.util.Observable.prototype.fireEvent
};
Ext.util.Observable.capture = function(c, b, a) {
    c.fireEvent = Ext.createInterceptor(c.fireEvent, b, a)
};
Ext.util.Observable.observe = function(a, b) {
    if (a) {
        if (!a.isObservable) {
            Ext.applyIf(a, new Ext.util.Observable());
            Ext.util.Observable.capture(a.prototype, a.fireEvent, a)
        }
        if (typeof b == "object") {
            a.on(b)
        }
        return a
    }
};
Ext.util.Observable.observeClass = Ext.util.Observable.observe;
Ext.util.Event = Ext.extend(Object,
        (function() {
            function b(e, f, g, d) {
                f.task = new Ext.util.DelayedTask();
                return function() {
                    f.task.delay(g.buffer, e, d, Ext.toArray(arguments))
                }
            }
            function a(e, f, g, d) {
                return function() {
                    var h = new Ext.util.DelayedTask();
                    if (!f.tasks) {
                        f.tasks = []
                    }
                    f.tasks.push(h);
                    h.delay(g.delay || 10, e, d, Ext.toArray(arguments))
                }
            }
            function c(e, f, g, d) {
                return function() {
                    f.ev.removeListener(f.fn, d);
                    return e.apply(d, arguments)
                }
            }
            return {
                isEvent : true,
                constructor : function(e, d) {
                    this.name = d;
                    this.observable = e;
                    this.listeners = []
                },
                addListener : function(f, e, d) {
                    var g = this, h;
                    e = e || g.observable;
                    if (!g.isListening(f, e)) {
                        h = g.createListener(f, e, d);
                        if (g.firing) {
                            g.listeners = g.listeners.slice(0)
                        }
                        g.listeners.push(h)
                    }
                },
                createListener : function(f, e, h) {
                    h = h || {};
                    e = e || this.observable;
                    var g = {
                        fn : f,
                        scope : e,
                        o : h,
                        ev : this
                    }, d = f;
                    if (h.delay) {
                        d = a(d, g, h, e)
                    }
                    if (h.buffer) {
                        d = b(d, g, h, e)
                    }
                    if (h.single) {
                        d = c(d, g, h, e)
                    }
                    g.fireFn = d;
                    return g
                },
                findListener : function(h, g) {
                    var f = this.listeners, d = f.length, j, e;
                    while (d--) {
                        j = f[d];
                        if (j) {
                            e = j.scope;
                            if (j.fn == h && (e == g || e == this.observable)) {
                                return d
                            }
                        }
                    }
                    return -1
                },
                isListening : function(e, d) {
                    return this.findListener(e, d) !== -1
                },
                removeListener : function(g, f) {
                    var h = this, e, i, d;
                    e = h.findListener(g, f);
                    if (e != -1) {
                        i = h.listeners[e];
                        if (h.firing) {
                            h.listeners = h.listeners.slice(0)
                        }
                        if (i.task) {
                            i.task.cancel();
                            delete i.task
                        }
                        d = i.tasks && i.tasks.length;
                        if (d) {
                            while (d--) {
                                i.tasks[d].cancel()
                            }
                            delete i.tasks
                        }
                        h.listeners.splice(e, 1);
                        return true
                    }
                    return false
                },
                clearListeners : function() {
                    var e = this.listeners, d = e.length;
                    while (d--) {
                        this.removeListener(e[d].fn, e[d].scope)
                    }
                },
                fire : function() {
                    var h = this, f = h.listeners, g = f.length, e, d, j;
                    if (g > 0) {
                        h.firing = true;
                        for (e = 0; e < g; e++) {
                            j = f[e];
                            d = arguments.length ? Array.prototype.slice.call(
                                    arguments, 0) : [];
                            if (j.o) {
                                d.push(j.o)
                            }
                            if (j
                                    && j.fireFn.apply(j.scope || h.observable,
                                            d) === false) {
                                return (h.firing = false)
                            }
                        }
                    }
                    h.firing = false;
                    return true
                }
            }
        })());
Ext.util.Stateful = Ext
        .extend(
                Ext.util.Observable,
                {
                    editing : false,
                    dirty : false,
                    persistanceProperty : "data",
                    constructor : function(a) {
                        Ext.applyIf(this, {
                            data : {}
                        });
                        this.modified = {};
                        this[this.persistanceProperty] = {};
                        Ext.util.Stateful.superclass.constructor.call(this, a)
                    },
                    get : function(a) {
                        return this[this.persistanceProperty][a]
                    },
                    set : function(j, f) {
                        var d = this, c = d.fields, h = d.modified, b = [], e, g, a;
                        if (arguments.length == 1 && Ext.isObject(j)) {
                            for (g in j) {
                                if (!j.hasOwnProperty(g)) {
                                    continue
                                }
                                e = c.get(g);
                                if (e && e.convert !== e.type.convert) {
                                    b.push(g);
                                    continue
                                }
                                d.set(g, j[g])
                            }
                            for (a = 0; a < b.length; a++) {
                                e = b[a];
                                d.set(e, j[e])
                            }
                        } else {
                            if (c) {
                                e = c.get(j);
                                if (e && e.convert) {
                                    f = e.convert(f, d)
                                }
                            }
                            d[d.persistanceProperty][j] = f;
                            if (e && e.persist && !d.isEqual(currentValue, f)) {
                                if (d.isModified(j)) {
                                    if (d.isEqual(h[j], f)) {
                                        delete h[j];
                                        d.dirty = false;
                                        for (g in h) {
                                            if (h.hasOwnProperty(g)) {
                                                d.dirty = true;
                                                break
                                            }
                                        }
                                    }
                                } else {
                                    d.dirty = true;
                                    h[j] = currentValue
                                }
                            }
                            if (!d.editing) {
                                d.afterEdit()
                            }
                        }
                    },
                    getChanges : function() {
                        var a = this.modified, b = {}, c;
                        for (c in a) {
                            if (a.hasOwnProperty(c)) {
                                b[c] = this[this.persistanceProperty][c]
                            }
                        }
                        return b
                    },
                    isModified : function(a) {
                        return !!(this.modified && this.modified
                                .hasOwnProperty(a))
                    },
                    setDirty : function() {
                        this.dirty = true;
                        if (!this.modified) {
                            this.modified = {}
                        }
                        this.fields
                                .each(
                                        function(a) {
                                            this.modified[a.name] = this[this.persistanceProperty][a.name]
                                        }, this)
                    },
                    markDirty : function() {
                        throw new Error(
                                "Stateful: markDirty has been deprecated. Please use setDirty.")
                    },
                    reject : function(a) {
                        var b = this.modified, c;
                        for (c in b) {
                            if (!b.hasOwnProperty(c)) {
                                continue
                            }
                            if (typeof b[c] != "function") {
                                this[this.persistanceProperty][c] = b[c]
                            }
                        }
                        this.dirty = false;
                        this.editing = false;
                        delete this.modified;
                        if (a !== true) {
                            this.afterReject()
                        }
                    },
                    commit : function(a) {
                        this.dirty = false;
                        this.editing = false;
                        delete this.modified;
                        if (a !== true) {
                            this.afterCommit()
                        }
                    },
                    copy : function(a) {
                        return new this.constructor(Ext.apply({},
                                this[this.persistanceProperty]), a
                                || this.internalId)
                    }
                });
Ext.util.HashMap = Ext.extend(Ext.util.Observable, {
    constructor : function(a) {
        this.addEvents("add", "clear", "remove", "replace");
        Ext.util.HashMap.superclass.constructor.call(this, a);
        this.clear(true)
    },
    getCount : function() {
        return this.length
    },
    getData : function(a, b) {
        if (b === undefined) {
            b = a;
            a = this.getKey(b)
        }
        return [ a, b ]
    },
    getKey : function(a) {
        return a.id
    },
    add : function(a, d) {
        var b = this, c;
        if (b.containsKey(a)) {
            throw new Error("This key already exists in the HashMap")
        }
        c = this.getData(a, d);
        a = c[0];
        d = c[1];
        b.map[a] = d;
        ++b.length;
        b.fireEvent("add", b, a, d);
        return d
    },
    replace : function(b, d) {
        var c = this, e = c.map, a;
        if (!c.containsKey(b)) {
            c.add(b, d)
        }
        a = e[b];
        e[b] = d;
        c.fireEvent("replace", c, b, d, a);
        return d
    },
    remove : function(b) {
        var a = this.findKey(b);
        if (a !== undefined) {
            return this.removeByKey(a)
        }
        return false
    },
    removeByKey : function(a) {
        var b = this, c;
        if (b.containsKey(a)) {
            c = b.map[a];
            delete b.map[a];
            --b.length;
            b.fireEvent("remove", b, a, c);
            return true
        }
        return false
    },
    get : function(a) {
        return this.map[a]
    },
    clear : function(a) {
        var b = this;
        b.map = {};
        b.length = 0;
        if (a !== true) {
            b.fireEvent("clear", b)
        }
        return b
    },
    containsKey : function(a) {
        return this.map[a] !== undefined
    },
    contains : function(a) {
        return this.containsKey(this.findKey(a))
    },
    getKeys : function() {
        return this.getArray(true)
    },
    getValues : function() {
        return this.getArray(false)
    },
    getArray : function(d) {
        var a = [], b, c = this.map;
        for (b in c) {
            if (c.hasOwnProperty(b)) {
                a.push(d ? b : c[b])
            }
        }
        return a
    },
    each : function(d, c) {
        var a = Ext.apply({}, this.map), b, e = this.length;
        c = c || this;
        for (b in a) {
            if (a.hasOwnProperty(b)) {
                if (d.call(c, b, a[b], e) === false) {
                    break
                }
            }
        }
        return this
    },
    clone : function() {
        var c = new Ext.util.HashMap(), b = this.map, a;
        c.suspendEvents();
        for (a in b) {
            if (b.hasOwnProperty(a)) {
                c.add(a, b[a])
            }
        }
        c.resumeEvents();
        return c
    },
    findKey : function(b) {
        var a, c = this.map;
        for (a in c) {
            if (c.hasOwnProperty(a) && c[a] === b) {
                return a
            }
        }
        return undefined
    }
});
Ext.util.MixedCollection = function(b, a) {
    this.items = [];
    this.map = {};
    this.keys = [];
    this.length = 0;
    this.addEvents("clear", "add", "replace", "remove", "sort");
    this.allowFunctions = b === true;
    if (a) {
        this.getKey = a
    }
    Ext.util.MixedCollection.superclass.constructor.call(this)
};
Ext
        .extend(
                Ext.util.MixedCollection,
                Ext.util.Observable,
                {
                    allowFunctions : false,
                    add : function(b, d) {
                        var e = d, c = b;
                        if (arguments.length == 1) {
                            e = c;
                            c = this.getKey(e)
                        }
                        if (typeof c != "undefined" && c !== null) {
                            var a = this.map[c];
                            if (typeof a != "undefined") {
                                return this.replace(c, e)
                            }
                            this.map[c] = e
                        }
                        this.length++;
                        this.items.push(e);
                        this.keys.push(c);
                        this.fireEvent("add", this.length - 1, e, c);
                        return e
                    },
                    getKey : function(a) {
                        return a.id
                    },
                    replace : function(c, d) {
                        if (arguments.length == 1) {
                            d = arguments[0];
                            c = this.getKey(d)
                        }
                        var a = this.map[c];
                        if (typeof c == "undefined" || c === null
                                || typeof a == "undefined") {
                            return this.add(c, d)
                        }
                        var b = this.indexOfKey(c);
                        this.items[b] = d;
                        this.map[c] = d;
                        this.fireEvent("replace", c, a, d);
                        return d
                    },
                    addAll : function(e) {
                        if (arguments.length > 1 || Ext.isArray(e)) {
                            var b = arguments.length > 1 ? arguments : e;
                            for ( var d = 0, a = b.length; d < a; d++) {
                                this.add(b[d])
                            }
                        } else {
                            for ( var c in e) {
                                if (!e.hasOwnProperty(c)) {
                                    continue
                                }
                                if (this.allowFunctions
                                        || typeof e[c] != "function") {
                                    this.add(c, e[c])
                                }
                            }
                        }
                    },
                    each : function(e, d) {
                        var b = [].concat(this.items);
                        for ( var c = 0, a = b.length; c < a; c++) {
                            if (e.call(d || b[c], b[c], c, a) === false) {
                                break
                            }
                        }
                    },
                    eachKey : function(d, c) {
                        for ( var b = 0, a = this.keys.length; b < a; b++) {
                            d.call(c || window, this.keys[b], this.items[b], b,
                                    a)
                        }
                    },
                    findBy : function(d, c) {
                        for ( var b = 0, a = this.items.length; b < a; b++) {
                            if (d
                                    .call(c || window, this.items[b],
                                            this.keys[b])) {
                                return this.items[b]
                            }
                        }
                        return null
                    },
                    insert : function(a, b, d) {
                        var c = b, e = d;
                        if (arguments.length == 2) {
                            e = c;
                            c = this.getKey(e)
                        }
                        if (this.containsKey(c)) {
                            this.suspendEvents();
                            this.removeByKey(c);
                            this.resumeEvents()
                        }
                        if (a >= this.length) {
                            return this.add(c, e)
                        }
                        this.length++;
                        this.items.splice(a, 0, e);
                        if (typeof c != "undefined" && c !== null) {
                            this.map[c] = e
                        }
                        this.keys.splice(a, 0, c);
                        this.fireEvent("add", a, e, c);
                        return e
                    },
                    remove : function(a) {
                        return this.removeAt(this.indexOf(a))
                    },
                    removeAll : function(a) {
                        Ext.each(a || [], function(b) {
                            this.remove(b)
                        }, this);
                        return this
                    },
                    removeAt : function(a) {
                        if (a < this.length && a >= 0) {
                            this.length--;
                            var c = this.items[a];
                            this.items.splice(a, 1);
                            var b = this.keys[a];
                            if (typeof b != "undefined") {
                                delete this.map[b]
                            }
                            this.keys.splice(a, 1);
                            this.fireEvent("remove", c, b);
                            return c
                        }
                        return false
                    },
                    removeByKey : function(a) {
                        return this.removeAt(this.indexOfKey(a))
                    },
                    removeKey : function() {
                        console
                                .warn("MixedCollection: removeKey has been deprecated. Please use removeByKey.");
                        return this.removeByKey.apply(this, arguments)
                    },
                    getCount : function() {
                        return this.length
                    },
                    indexOf : function(a) {
                        return this.items.indexOf(a)
                    },
                    indexOfKey : function(a) {
                        return this.keys.indexOf(a)
                    },
                    get : function(b) {
                        var a = this.map[b], c = a !== undefined ? a
                                : (typeof b == "number") ? this.items[b]
                                        : undefined;
                        return typeof c != "function" || this.allowFunctions ? c
                                : null
                    },
                    item : function() {
                        console
                                .warn("MixedCollection: item has been deprecated. Please use get.");
                        return this.get.apply(this, arguments)
                    },
                    getAt : function(a) {
                        return this.items[a]
                    },
                    itemAt : function() {
                        console
                                .warn("MixedCollection: itemAt has been deprecated. Please use getAt.");
                        return this.getAt.apply(this, arguments)
                    },
                    getByKey : function(a) {
                        return this.map[a]
                    },
                    key : function() {
                        console
                                .warn("MixedCollection: key has been deprecated. Please use getByKey.");
                        return this.getByKey.apply(this, arguments)
                    },
                    contains : function(a) {
                        return this.indexOf(a) != -1
                    },
                    containsKey : function(a) {
                        return typeof this.map[a] != "undefined"
                    },
                    clear : function() {
                        this.length = 0;
                        this.items = [];
                        this.keys = [];
                        this.map = {};
                        this.fireEvent("clear")
                    },
                    first : function() {
                        return this.items[0]
                    },
                    last : function() {
                        return this.items[this.length - 1]
                    },
                    _sort : function(j, a, h) {
                        var d, e, b = String(a).toUpperCase() == "DESC" ? -1
                                : 1, g = [], k = this.keys, f = this.items;
                        h = h || function(i, c) {
                            return i - c
                        };
                        for (d = 0, e = f.length; d < e; d++) {
                            g[g.length] = {
                                key : k[d],
                                value : f[d],
                                index : d
                            }
                        }
                        g.sort(function(i, c) {
                            var l = h(i[j], c[j]) * b;
                            if (l === 0) {
                                l = (i.index < c.index ? -1 : 1)
                            }
                            return l
                        });
                        for (d = 0, e = g.length; d < e; d++) {
                            f[d] = g[d].value;
                            k[d] = g[d].key
                        }
                        this.fireEvent("sort", this)
                    },
                    sort : function(c, e) {
                        var d = c;
                        if (Ext.isString(c)) {
                            d = [ new Ext.util.Sorter({
                                property : c,
                                direction : e || "ASC"
                            }) ]
                        } else {
                            if (c instanceof Ext.util.Sorter) {
                                d = [ c ]
                            } else {
                                if (Ext.isObject(c)) {
                                    d = [ new Ext.util.Sorter(c) ]
                                }
                            }
                        }
                        var b = d.length;
                        if (b == 0) {
                            return
                        }
                        var a = function(h, g) {
                            var f = d[0].sort(h, g), k = d.length, j;
                            for (j = 1; j < k; j++) {
                                f = f || d[j].sort.call(this, h, g)
                            }
                            return f
                        };
                        this.sortBy(a)
                    },
                    sortBy : function(c) {
                        var b = this.items, f = this.keys, e = b.length, a = [], d;
                        for (d = 0; d < e; d++) {
                            a[d] = {
                                key : f[d],
                                value : b[d],
                                index : d
                            }
                        }
                        a.sort(function(h, g) {
                            var i = c(h.value, g.value);
                            if (i === 0) {
                                i = (h.index < g.index ? -1 : 1)
                            }
                            return i
                        });
                        for (d = 0; d < e; d++) {
                            b[d] = a[d].value;
                            f[d] = a[d].key
                        }
                        this.fireEvent("sort", this)
                    },
                    reorder : function(d) {
                        this.suspendEvents();
                        var b = this.items, c = 0, f = b.length, a = [], e = [], g;
                        for (g in d) {
                            a[d[g]] = b[g]
                        }
                        for (c = 0; c < f; c++) {
                            if (d[c] == undefined) {
                                e.push(b[c])
                            }
                        }
                        for (c = 0; c < f; c++) {
                            if (a[c] == undefined) {
                                a[c] = e.shift()
                            }
                        }
                        this.clear();
                        this.addAll(a);
                        this.resumeEvents();
                        this.fireEvent("sort", this)
                    },
                    sortByKey : function(a, b) {
                        this
                                ._sort(
                                        "key",
                                        a,
                                        b
                                                || function(d, c) {
                                                    var f = String(d)
                                                            .toUpperCase(), e = String(
                                                            c).toUpperCase();
                                                    return f > e ? 1
                                                            : (f < e ? -1 : 0)
                                                })
                    },
                    keySort : function() {
                        console
                                .warn("MixedCollection: keySort has been deprecated. Please use sortByKey.");
                        return this.sortByKey.apply(this, arguments)
                    },
                    getRange : function(e, a) {
                        var b = this.items;
                        if (b.length < 1) {
                            return []
                        }
                        e = e || 0;
                        a = Math.min(typeof a == "undefined" ? this.length - 1
                                : a, this.length - 1);
                        var c, d = [];
                        if (e <= a) {
                            for (c = e; c <= a; c++) {
                                d[d.length] = b[c]
                            }
                        } else {
                            for (c = e; c >= a; c--) {
                                d[d.length] = b[c]
                            }
                        }
                        return d
                    },
                    filter : function(d, c, f, a) {
                        var b = [];
                        if (Ext.isString(d)) {
                            b.push(new Ext.util.Filter({
                                property : d,
                                value : c,
                                anyMatch : f,
                                caseSensitive : a
                            }))
                        } else {
                            if (Ext.isArray(d) || d instanceof Ext.util.Filter) {
                                b = b.concat(d)
                            }
                        }
                        var e = function(g) {
                            var m = true, n = b.length, h;
                            for (h = 0; h < n; h++) {
                                var l = b[h], k = l.filterFn, j = l.scope;
                                m = m && k.call(j, g)
                            }
                            return m
                        };
                        return this.filterBy(e)
                    },
                    filterBy : function(e, d) {
                        var a = new Ext.util.MixedCollection(), g = this.keys, b = this.items, f = b.length, c;
                        a.getKey = this.getKey;
                        for (c = 0; c < f; c++) {
                            if (e.call(d || this, b[c], g[c])) {
                                a.add(g[c], b[c])
                            }
                        }
                        return a
                    },
                    findIndex : function(c, b, e, d, a) {
                        if (Ext.isEmpty(b, false)) {
                            return -1
                        }
                        b = this.createValueMatcher(b, d, a);
                        return this.findIndexBy(function(f) {
                            return f && b.test(f[c])
                        }, null, e)
                    },
                    findIndexBy : function(f, e, g) {
                        var b = this.keys, d = this.items;
                        for ( var c = (g || 0), a = d.length; c < a; c++) {
                            if (f.call(e || this, d[c], b[c])) {
                                return c
                            }
                        }
                        return -1
                    },
                    createValueMatcher : function(c, e, a, b) {
                        if (!c.exec) {
                            var d = Ext.util.Format.escapeRegex;
                            c = String(c);
                            if (e === true) {
                                c = d(c)
                            } else {
                                c = "^" + d(c);
                                if (b === true) {
                                    c += "$"
                                }
                            }
                            c = new RegExp(c, a ? "" : "i")
                        }
                        return c
                    },
                    clone : function() {
                        var e = new Ext.util.MixedCollection();
                        var b = this.keys, d = this.items;
                        for ( var c = 0, a = d.length; c < a; c++) {
                            e.add(b[c], d[c])
                        }
                        e.getKey = this.getKey;
                        return e
                    }
                });
Ext.AbstractManager = Ext.extend(Object, {
    typeName : "type",
    constructor : function(a) {
        Ext.apply(this, a || {});
        this.all = new Ext.util.HashMap();
        this.types = {}
    },
    get : function(a) {
        return this.all.get(a)
    },
    register : function(a) {
        this.all.add(a)
    },
    unregister : function(a) {
        this.all.remove(a)
    },
    registerType : function(b, a) {
        this.types[b] = a;
        a[this.typeName] = b
    },
    isRegistered : function(a) {
        return this.types[a] !== undefined
    },
    create : function(a, d) {
        var b = a[this.typeName] || a.type || d, c = this.types[b];
        if (c == undefined) {
            throw new Error(Ext.util.Format.format(
                    "The '{0}' type has not been registered with this manager",
                    b))
        }
        return new c(a)
    },
    onAvailable : function(d, c, b) {
        var a = this.all;
        a.on("add", function(e, f) {
            if (f.id == d) {
                c.call(b || f, f);
                a.un("add", c, b)
            }
        })
    },
    each : function(b, a) {
        this.all.each(b, a || this)
    },
    getCount : function() {
        return this.all.getCount()
    }
});
Ext.util.DelayedTask = function(d, c, a) {
    var e = this, f, b = function() {
        clearInterval(f);
        f = null;
        d.apply(c, a || [])
    };
    this.delay = function(h, j, i, g) {
        e.cancel();
        d = j || d;
        c = i || c;
        a = g || a;
        f = setInterval(b, h)
    };
    this.cancel = function() {
        if (f) {
            clearInterval(f);
            f = null
        }
    }
};
Ext.util.GeoLocation = Ext
        .extend(
                Ext.util.Observable,
                {
                    autoUpdate : true,
                    latitude : null,
                    longitude : null,
                    accuracy : null,
                    altitude : null,
                    altitudeAccuracy : null,
                    heading : null,
                    speed : null,
                    timestamp : null,
                    allowHighAccuracy : false,
                    timeout : Infinity,
                    maximumAge : 0,
                    setMaximumAge : function(a) {
                        this.maximumAge = a;
                        this.setAutoUpdate(this.autoUpdate)
                    },
                    setTimeout : function(a) {
                        this.timeout = a;
                        this.setAutoUpdate(this.autoUpdate)
                    },
                    setAllowHighAccuracy : function(a) {
                        this.allowHighAccuracy = a;
                        this.setAutoUpdate(this.autoUpdate)
                    },
                    provider : null,
                    watchOperation : null,
                    constructor : function(a) {
                        Ext.apply(this, a);
                        this.coords = this;
                        if (Ext.supports.GeoLocation) {
                            this.provider = this.provider
                                    || (navigator.geolocation ? navigator.geolocation
                                            : (window.google || {}).gears ? google.gears.factory
                                                    .create("beta.geolocation")
                                                    : null)
                        }
                        this.addEvents("update", "locationerror",
                                "locationupdate");
                        Ext.util.GeoLocation.superclass.constructor.call(this);
                        if (this.autoUpdate) {
                            var b = this;
                            setTimeout(function() {
                                b.setAutoUpdate(b.autoUpdate)
                            }, 0)
                        }
                    },
                    setAutoUpdate : function(a) {
                        if (this.watchOperation !== null) {
                            this.provider.clearWatch(this.watchOperation);
                            this.watchOperation = null
                        }
                        if (!a) {
                            return true
                        }
                        if (!Ext.supports.GeoLocation) {
                            this.fireEvent("locationerror", this, false, false,
                                    true, null);
                            return false
                        }
                        try {
                            this.watchOperation = this.provider.watchPosition(
                                    Ext.createDelegate(this.fireUpdate, this),
                                    Ext.createDelegate(this.fireError, this),
                                    this.parseOptions())
                        } catch (b) {
                            this.autoUpdate = false;
                            this.fireEvent("locationerror", this, false, false,
                                    true, b.message);
                            return false
                        }
                        return true
                    },
                    updateLocation : function(g, a, c) {
                        var b = this;
                        var f = function(h, e) {
                            if (e) {
                                b.fireError(e)
                            } else {
                                b.fireEvent("locationerror", b, false, false,
                                        true, h)
                            }
                            if (g) {
                                g.call(a || b, null, b)
                            }
                            b.fireEvent("update", false, b)
                        };
                        if (!Ext.supports.GeoLocation) {
                            setTimeout(function() {
                                f(null)
                            }, 0);
                            return
                        }
                        try {
                            this.provider.getCurrentPosition(function(e) {
                                b.fireUpdate(e);
                                if (g) {
                                    g.call(a || b, b, b)
                                }
                                b.fireEvent("update", b, b)
                            }, function(e) {
                                f(null, e)
                            }, c ? c : this.parseOptions())
                        } catch (d) {
                            setTimeout(function() {
                                f(d.message)
                            }, 0)
                        }
                    },
                    fireUpdate : function(a) {
                        this.timestamp = a.timestamp;
                        this.latitude = a.coords.latitude;
                        this.longitude = a.coords.longitude;
                        this.accuracy = a.coords.accuracy;
                        this.altitude = a.coords.altitude;
                        this.altitudeAccuracy = a.coords.altitudeAccuracy;
                        this.heading = typeof a.coords.heading == "undefined" ? null
                                : a.coords.heading;
                        this.speed = typeof a.coords.speed == "undefined" ? null
                                : a.coords.speed;
                        this.fireEvent("locationupdate", this)
                    },
                    fireError : function(a) {
                        this.fireEvent("locationerror", this,
                                a.code == a.TIMEOUT,
                                a.code == a.PERMISSION_DENIED,
                                a.code == a.POSITION_UNAVAILABLE,
                                a.message == undefined ? null : a.message)
                    },
                    parseOptions : function() {
                        var a = {
                            maximumAge : this.maximumAge,
                            allowHighAccuracy : this.allowHighAccuracy
                        };
                        if (this.timeout !== Infinity) {
                            a.timeout = this.timeout
                        }
                        return a
                    },
                    getLocation : function(c, a) {
                        var b = this;
                        if (this.latitude !== null) {
                            c.call(a || b, b, b)
                        } else {
                            b.updateLocation(c, a)
                        }
                    }
                });
Ext.util.Region = Ext.extend(Object,
        {
            constructor : function(d, f, a, c) {
                var e = this;
                e.top = d;
                e[1] = d;
                e.right = f;
                e.bottom = a;
                e.left = c;
                e[0] = c
            },
            contains : function(b) {
                var a = this;
                return (b.left >= a.left && b.right <= a.right
                        && b.top >= a.top && b.bottom <= a.bottom)
            },
            intersect : function(g) {
                var f = this, d = Math.max(f.top, g.top), e = Math.min(f.right,
                        g.right), a = Math.min(f.bottom, g.bottom), c = Math
                        .max(f.left, g.left);
                if (a > d && e > c) {
                    return new Ext.util.Region(d, e, a, c)
                } else {
                    return false
                }
            },
            union : function(g) {
                var f = this, d = Math.min(f.top, g.top), e = Math.max(f.right,
                        g.right), a = Math.max(f.bottom, g.bottom), c = Math
                        .min(f.left, g.left);
                return new Ext.util.Region(d, e, a, c)
            },
            constrainTo : function(b) {
                var a = this, c = Ext.util.Numbers.constrain;
                a.top = c(a.top, b.top, b.bottom);
                a.bottom = c(a.bottom, b.top, b.bottom);
                a.left = c(a.left, b.left, b.right);
                a.right = c(a.right, b.left, b.right);
                return a
            },
            adjust : function(d, f, a, c) {
                var e = this;
                e.top += d;
                e.left += c;
                e.right += f;
                e.bottom += a;
                return e
            },
            getOutOfBoundOffset : function(a, b) {
                if (!Ext.isObject(a)) {
                    if (a == "x") {
                        return this.getOutOfBoundOffsetX(b)
                    } else {
                        return this.getOutOfBoundOffsetY(b)
                    }
                } else {
                    b = a;
                    var c = new Ext.util.Offset();
                    c.x = this.getOutOfBoundOffsetX(b.x);
                    c.y = this.getOutOfBoundOffsetY(b.y);
                    return c
                }
            },
            getOutOfBoundOffsetX : function(a) {
                if (a <= this.left) {
                    return this.left - a
                } else {
                    if (a >= this.right) {
                        return this.right - a
                    }
                }
                return 0
            },
            getOutOfBoundOffsetY : function(a) {
                if (a <= this.top) {
                    return this.top - a
                } else {
                    if (a >= this.bottom) {
                        return this.bottom - a
                    }
                }
                return 0
            },
            isOutOfBound : function(a, b) {
                if (!Ext.isObject(a)) {
                    if (a == "x") {
                        return this.isOutOfBoundX(b)
                    } else {
                        return this.isOutOfBoundY(b)
                    }
                } else {
                    b = a;
                    return (this.isOutOfBoundX(b.x) || this.isOutOfBoundY(b.y))
                }
            },
            isOutOfBoundX : function(a) {
                return (a < this.left || a > this.right)
            },
            isOutOfBoundY : function(a) {
                return (a < this.top || a > this.bottom)
            },
            restrict : function(b, d, a) {
                if (Ext.isObject(b)) {
                    var c;
                    a = d;
                    d = b;
                    if (d.copy) {
                        c = d.copy()
                    } else {
                        c = {
                            x : d.x,
                            y : d.y
                        }
                    }
                    c.x = this.restrictX(d.x, a);
                    c.y = this.restrictY(d.y, a);
                    return c
                } else {
                    if (b == "x") {
                        return this.restrictX(d, a)
                    } else {
                        return this.restrictY(d, a)
                    }
                }
            },
            restrictX : function(b, a) {
                if (!a) {
                    a = 1
                }
                if (b <= this.left) {
                    b -= (b - this.left) * a
                } else {
                    if (b >= this.right) {
                        b -= (b - this.right) * a
                    }
                }
                return b
            },
            restrictY : function(b, a) {
                if (!a) {
                    a = 1
                }
                if (b <= this.top) {
                    b -= (b - this.top) * a
                } else {
                    if (b >= this.bottom) {
                        b -= (b - this.bottom) * a
                    }
                }
                return b
            },
            getSize : function() {
                return {
                    width : this.right - this.left,
                    height : this.bottom - this.top
                }
            },
            copy : function() {
                return new Ext.util.Region(this.top, this.right, this.bottom,
                        this.left)
            },
            toString : function() {
                return "Region[" + this.top + "," + this.right + ","
                        + this.bottom + "," + this.left + "]"
            },
            translateBy : function(a) {
                this.left += a.x;
                this.right += a.x;
                this.top += a.y;
                this.bottom += a.y;
                return this
            },
            round : function() {
                this.top = Math.round(this.top);
                this.right = Math.round(this.right);
                this.bottom = Math.round(this.bottom);
                this.left = Math.round(this.left);
                return this
            },
            equals : function(a) {
                return (this.top == a.top && this.right == a.right
                        && this.bottom == a.bottom && this.left == a.left)
            }
        });
Ext.util.Region.getRegion = function(a) {
    return Ext.fly(a).getPageBox(true)
};
Ext.util.Region.from = function(a) {
    return new Ext.util.Region(a.top, a.right, a.bottom, a.left)
};
Ext.util.Point = Ext.extend(Object,
        {
            constructor : function(a, b) {
                this.x = (a != null && !isNaN(a)) ? a : 0;
                this.y = (b != null && !isNaN(b)) ? b : 0;
                return this
            },
            copy : function() {
                return new Ext.util.Point(this.x, this.y)
            },
            copyFrom : function(a) {
                this.x = a.x;
                this.y = a.y;
                return this
            },
            toString : function() {
                return "Point[" + this.x + "," + this.y + "]"
            },
            equals : function(a) {
                return (this.x == a.x && this.y == a.y)
            },
            isWithin : function(b, a) {
                if (!Ext.isObject(a)) {
                    a = {
                        x : a
                    };
                    a.y = a.x
                }
                return (this.x <= b.x + a.x && this.x >= b.x - a.x
                        && this.y <= b.y + a.y && this.y >= b.y - a.y)
            },
            translate : function(a, b) {
                if (a != null && !isNaN(a)) {
                    this.x += a
                }
                if (b != null && !isNaN(b)) {
                    this.y += b
                }
            },
            roundedEquals : function(a) {
                return (Math.round(this.x) == Math.round(a.x) && Math
                        .round(this.y) == Math.round(a.y))
            }
        });
Ext.util.Point.fromEvent = function(c) {
    var b = (c.changedTouches && c.changedTouches.length > 0) ? c.changedTouches[0]
            : c;
    return new Ext.util.Point(b.pageX, b.pageY)
};
Ext.util.Offset = Ext.extend(Object, {
    constructor : function(a, b) {
        this.x = (a != null && !isNaN(a)) ? a : 0;
        this.y = (b != null && !isNaN(b)) ? b : 0;
        return this
    },
    copy : function() {
        return new Ext.util.Offset(this.x, this.y)
    },
    copyFrom : function(a) {
        this.x = a.x;
        this.y = a.y
    },
    toString : function() {
        return "Offset[" + this.x + "," + this.y + "]"
    },
    equals : function(a) {
        if (!(a instanceof Ext.util.Offset)) {
            throw new Error("offset must be an instance of Ext.util.Offset")
        }
        return (this.x == a.x && this.y == a.y)
    },
    round : function(b) {
        if (!isNaN(b)) {
            var a = Math.pow(10, b);
            this.x = Math.round(this.x * a) / a;
            this.y = Math.round(this.y * a) / a
        } else {
            this.x = Math.round(this.x);
            this.y = Math.round(this.y)
        }
    },
    isZero : function() {
        return this.x == 0 && this.y == 0
    }
});
Ext.util.Offset.fromObject = function(a) {
    return new Ext.util.Offset(a.x, a.y)
};
Ext.Template = Ext
        .extend(
                Object,
                {
                    constructor : function(d) {
                        var f = this, b = arguments, a = [], g, c, e;
                        f.initialConfig = {};
                        if (Ext.isArray(d)) {
                            d = d.join("")
                        } else {
                            if (b.length > 1) {
                                for (c = 0, e = b.length; c < e; c++) {
                                    g = b[c];
                                    if (typeof g == "object") {
                                        Ext.apply(f.initialConfig, g);
                                        Ext.apply(f, g)
                                    } else {
                                        a.push(g)
                                    }
                                }
                                d = a.join("")
                            }
                        }
                        f.html = d;
                        if (f.compiled) {
                            f.compile()
                        }
                    },
                    isTemplate : true,
                    disableFormats : false,
                    re : /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
                    applyTemplate : function(a) {
                        var f = this, c = f.disableFormats !== true, e = Ext.util.Format, b = f;
                        if (f.compiled) {
                            return f.compiled(a)
                        }
                        function d(g, i, j, h) {
                            if (j && c) {
                                if (h) {
                                    h = [ a[i] ].concat(new Function("return ["
                                            + h + "];")())
                                } else {
                                    h = [ a[i] ]
                                }
                                if (j.substr(0, 5) == "this.") {
                                    return b[j.substr(5)].apply(b, h)
                                } else {
                                    return e[j].apply(e, h)
                                }
                            } else {
                                return a[i] !== undefined ? a[i] : ""
                            }
                        }
                        return f.html.replace(f.re, d)
                    },
                    set : function(a, c) {
                        var b = this;
                        b.html = a;
                        b.compiled = null;
                        return c ? b.compile() : b
                    },
                    compileARe : /\\/g,
                    compileBRe : /(\r\n|\n)/g,
                    compileCRe : /'/g,
                    compile : function() {
                        var me = this, fm = Ext.util.Format, useFormat = me.disableFormats !== true, body, bodyReturn;
                        function fn(m, name, format, args) {
                            if (format && useFormat) {
                                args = args ? "," + args : "";
                                if (format.substr(0, 5) != "this.") {
                                    format = "fm." + format + "("
                                } else {
                                    format = "this." + format.substr(5) + "("
                                }
                            } else {
                                args = "";
                                format = "(values['" + name
                                        + "'] == undefined ? '' : "
                            }
                            return "'," + format + "values['" + name + "']"
                                    + args + ") ,'"
                        }
                        bodyReturn = me.html.replace(me.compileARe, "\\\\")
                                .replace(me.compileBRe, "\\n").replace(
                                        me.compileCRe, "\\'")
                                .replace(me.re, fn);
                        body = "this.compiled = function(values){ return ['"
                                + bodyReturn + "'].join('');};";
                        eval(body);
                        return me
                    },
                    insertFirst : function(b, a, c) {
                        return this.doInsert("afterBegin", b, a, c)
                    },
                    insertBefore : function(b, a, c) {
                        return this.doInsert("beforeBegin", b, a, c)
                    },
                    insertAfter : function(b, a, c) {
                        return this.doInsert("afterEnd", b, a, c)
                    },
                    append : function(b, a, c) {
                        return this.doInsert("beforeEnd", b, a, c)
                    },
                    doInsert : function(c, e, b, a) {
                        e = Ext.getDom(e);
                        var d = Ext.DomHelper.insertHtml(c, e, this
                                .applyTemplate(b));
                        return a ? Ext.get(d, true) : d
                    },
                    overwrite : function(b, a, c) {
                        b = Ext.getDom(b);
                        b.innerHTML = this.applyTemplate(a);
                        return c ? Ext.get(b.firstChild, true) : b.firstChild
                    }
                });
Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;
Ext.Template.from = function(b, a) {
    b = Ext.getDom(b);
    return new Ext.Template(b.value || b.innerHTML, a || "")
};
Ext.XTemplate = Ext
        .extend(
                Ext.Template,
                {
                    argsRe : /<tpl\b[^>]*>((?:(?=([^<]+))\2|<(?!tpl\b[^>]*>))*?)<\/tpl>/,
                    nameRe : /^<tpl\b[^>]*?for="(.*?)"/,
                    ifRe : /^<tpl\b[^>]*?if="(.*?)"/,
                    execRe : /^<tpl\b[^>]*?exec="(.*?)"/,
                    constructor : function() {
                        Ext.XTemplate.superclass.constructor.apply(this,
                                arguments);
                        var y = this, h = y.html, v = y.argsRe, c = y.nameRe, t = y.ifRe, x = y.execRe, o = 0, j = [], n = "values", w = "parent", k = "xindex", l = "xcount", d = "return ", b = "with(values){ ", p, f, u, a, e, g, q, z, s;
                        h = [ "<tpl>", h, "</tpl>" ].join("");
                        while ((p = h.match(v))) {
                            e = null;
                            g = null;
                            q = null;
                            f = p[0].match(c);
                            u = p[0].match(t);
                            a = p[0].match(x);
                            e = u ? u[1] : null;
                            if (e) {
                                g = new Function(n, w, k, l, b + "try{" + d
                                        + Ext.util.Format.htmlDecode(e)
                                        + ";}catch(e){return;}}")
                            }
                            e = a ? a[1] : null;
                            if (e) {
                                q = new Function(n, w, k, l, b
                                        + Ext.util.Format.htmlDecode(e) + ";}")
                            }
                            z = f ? f[1] : null;
                            if (z) {
                                if (z === ".") {
                                    z = n
                                } else {
                                    if (z === "..") {
                                        z = w
                                    }
                                }
                                z = new Function(n, w, "try{" + b + d + z
                                        + ";}}catch(e){return;}")
                            }
                            j.push({
                                id : o,
                                target : z,
                                exec : q,
                                test : g,
                                body : p[1] || ""
                            });
                            h = h.replace(p[0], "{xtpl" + o + "}");
                            o = o + 1
                        }
                        for (s = j.length - 1; s >= 0; --s) {
                            y.compileTpl(j[s])
                        }
                        y.master = j[j.length - 1];
                        y.tpls = j
                    },
                    applySubTemplate : function(g, a, c, e, f) {
                        var d = this, b = d.tpls[g];
                        return b.compiled.call(d, a, c, e, f)
                    },
                    codeRe : /\{\[((?:\\\]|.|\n)*?)\]\}/g,
                    re : /\{([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\/]\s?[\d\.\+\-\*\/\(\)]+)?\}/g,
                    compileTpl : function(tpl) {
                        var fm = Ext.util.Format, me = this, useFormat = me.disableFormats !== true, body, bodyReturn, evaluatedFn;
                        function fn(m, name, format, args, math) {
                            var v;
                            if (name.substr(0, 4) == "xtpl") {
                                return "',this.applySubTemplate("
                                        + name.substr(4)
                                        + ", values, parent, xindex, xcount),'"
                            }
                            if (name == ".") {
                                v = 'typeof values == "string" ? values : ""'
                            } else {
                                if (name == "#") {
                                    v = "xindex"
                                } else {
                                    if (name.substr(0, 7) == "parent.") {
                                        v = name
                                    } else {
                                        if (name.indexOf(".") != -1) {
                                            v = "values." + name
                                        } else {
                                            v = "values['" + name + "']"
                                        }
                                    }
                                }
                            }
                            if (math) {
                                v = "(" + v + math + ")"
                            }
                            if (format && useFormat) {
                                args = args ? "," + args : "";
                                if (format.substr(0, 5) != "this.") {
                                    format = "fm." + format + "("
                                } else {
                                    format = "this." + format.substr(5) + "("
                                }
                            } else {
                                args = "";
                                format = "(" + v + " === undefined ? '' : "
                            }
                            return "'," + format + v + args + "),'"
                        }
                        function codeFn(m, code) {
                            return "',(" + code.replace(me.compileARe, "'")
                                    + "),'"
                        }
                        bodyReturn = tpl.body.replace(me.compileBRe, "\\n")
                                .replace(me.compileCRe, "\\'").replace(me.re,
                                        fn).replace(me.codeRe, codeFn);
                        body = "evaluatedFn = function(values, parent, xindex, xcount){return ['"
                                + bodyReturn + "'].join('');};";
                        eval(body);
                        tpl.compiled = function(values, parent, xindex, xcount) {
                            var vs, length, buffer, i;
                            if (tpl.test
                                    && !tpl.test.call(me, values, parent,
                                            xindex, xcount)) {
                                return ""
                            }
                            vs = tpl.target ? tpl.target.call(me, values,
                                    parent) : values;
                            if (!vs) {
                                return ""
                            }
                            parent = tpl.target ? values : parent;
                            if (tpl.target && Ext.isArray(vs)) {
                                buffer = [], length = vs.length;
                                if (tpl.exec) {
                                    for (i = 0; i < length; i++) {
                                        buffer[buffer.length] = evaluatedFn
                                                .call(me, vs[i], parent, i + 1,
                                                        length);
                                        tpl.exec.call(me, vs[i], parent, i + 1,
                                                length)
                                    }
                                } else {
                                    for (i = 0; i < length; i++) {
                                        buffer[buffer.length] = evaluatedFn
                                                .call(me, vs[i], parent, i + 1,
                                                        length)
                                    }
                                }
                                return buffer.join("")
                            }
                            if (tpl.exec) {
                                tpl.exec.call(me, vs, parent, xindex, xcount)
                            }
                            return evaluatedFn.call(me, vs, parent, xindex,
                                    xcount)
                        };
                        return this
                    },
                    applyTemplate : function(a) {
                        return this.master.compiled.call(this, a, {}, 1, 1)
                    },
                    compile : function() {
                        return this
                    }
                });
Ext.XTemplate.prototype.apply = Ext.XTemplate.prototype.applyTemplate;
Ext.XTemplate.from = function(b, a) {
    b = Ext.getDom(b);
    return new Ext.XTemplate(b.value || b.innerHTML, a || {})
};
Ext.util.Sorter = Ext
        .extend(
                Object,
                {
                    direction : "ASC",
                    constructor : function(a) {
                        Ext.apply(this, a);
                        if (this.property == undefined
                                && this.sorterFn == undefined) {
                            throw "A Sorter requires either a property or a sorter function"
                        }
                        this.sort = this.createSortFunction(this.sorterFn
                                || this.defaultSorterFn)
                    },
                    createSortFunction : function(b) {
                        var c = this, d = c.property, e = c.direction, a = e
                                .toUpperCase() == "DESC" ? -1 : 1;
                        return function(g, f) {
                            return a * b.call(c, g, f)
                        }
                    },
                    defaultSorterFn : function(b, a) {
                        var d = this.getRoot(b)[this.property], c = this
                                .getRoot(a)[this.property];
                        return d > c ? 1 : (d < c ? -1 : 0)
                    },
                    getRoot : function(a) {
                        return this.root == undefined ? a : a[this.root]
                    }
                });
Ext.util.Filter = Ext
        .extend(
                Object,
                {
                    anyMatch : false,
                    exactMatch : false,
                    caseSensitive : false,
                    constructor : function(a) {
                        Ext.apply(this, a);
                        this.filter = this.filter || this.filterFn;
                        if (this.filter == undefined) {
                            if (this.property == undefined
                                    || this.value == undefined) {
                            } else {
                                this.filter = this.createFilterFn()
                            }
                            this.filterFn = this.filter
                        }
                    },
                    createFilterFn : function() {
                        var a = this, c = a.createValueMatcher(), b = a.property;
                        return function(d) {
                            return c.test(a.getRoot.call(a, d)[b])
                        }
                    },
                    getRoot : function(a) {
                        return this.root == undefined ? a : a[this.root]
                    },
                    createValueMatcher : function() {
                        var d = this, e = d.value, f = d.anyMatch, c = d.exactMatch, a = d.caseSensitive, b = Ext.util.Format.escapeRegex;
                        if (!e.exec) {
                            e = String(e);
                            if (f === true) {
                                e = b(e)
                            } else {
                                e = "^" + b(e);
                                if (c === true) {
                                    e += "$"
                                }
                            }
                            e = new RegExp(e, a ? "" : "i")
                        }
                        return e
                    }
                });
Ext.util.Functions = {
    createInterceptor : function(d, c, b, a) {
        var e = d;
        if (!Ext.isFunction(c)) {
            return d
        } else {
            return function() {
                var g = this, f = arguments;
                c.target = g;
                c.method = d;
                return (c.apply(b || g || window, f) !== false) ? d.apply(g
                        || window, f) : a || null
            }
        }
    },
    createDelegate : function(c, d, b, a) {
        if (!Ext.isFunction(c)) {
            return c
        }
        return function() {
            var f = b || arguments;
            if (a === true) {
                f = Array.prototype.slice.call(arguments, 0);
                f = f.concat(b)
            } else {
                if (Ext.isNumber(a)) {
                    f = Array.prototype.slice.call(arguments, 0);
                    var e = [ a, 0 ].concat(b);
                    Array.prototype.splice.apply(f, e)
                }
            }
            return c.apply(d || window, f)
        }
    },
    defer : function(d, c, e, b, a) {
        d = Ext.util.Functions.createDelegate(d, e, b, a);
        if (c > 0) {
            return setTimeout(d, c)
        }
        d();
        return 0
    },
    createSequence : function(c, b, a) {
        if (!Ext.isFunction(b)) {
            return c
        } else {
            return function() {
                var d = c.apply(this || window, arguments);
                b.apply(a || this || window, arguments);
                return d
            }
        }
    }
};
Ext.defer = Ext.util.Functions.defer;
Ext.createInterceptor = Ext.util.Functions.createInterceptor;
Ext.createSequence = Ext.util.Functions.createSequence;
Ext.createDelegate = Ext.util.Functions.createDelegate;
Ext.util.Date = {
    getElapsed : function(b, a) {
        return Math.abs(b - (a || new Date))
    }
};
Ext.util.Numbers = {
    toFixedBroken : (0.9).toFixed() != 1,
    constrain : function(c, b, a) {
        c = parseFloat(c);
        if (!isNaN(b)) {
            c = Math.max(c, b)
        }
        if (!isNaN(a)) {
            c = Math.min(c, a)
        }
        return c
    },
    toFixed : function(c, a) {
        if (Ext.util.Numbers.toFixedBroken) {
            a = a || 0;
            var b = Math.pow(10, a);
            return Math.round(c * b) / b
        }
        return c.toFixed(a)
    }
};
Ext.util.Format = {
    defaultDateFormat : "m/d/Y",
    escapeRe : /('|\\)/g,
    trimRe : /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,
    formatRe : /\{(\d+)\}/g,
    escapeRegexRe : /([-.*+?^${}()|[\]\/\\])/g,
    ellipsis : function(c, a, d) {
        if (c && c.length > a) {
            if (d) {
                var e = c.substr(0, a - 2), b = Math.max(e.lastIndexOf(" "), e
                        .lastIndexOf("."), e.lastIndexOf("!"), e
                        .lastIndexOf("?"));
                if (b != -1 && b >= (a - 15)) {
                    return e.substr(0, b) + "..."
                }
            }
            return c.substr(0, a - 3) + "..."
        }
        return c
    },
    escapeRegex : function(a) {
        return a.replace(Ext.util.Format.escapeRegexRe, "\\$1")
    },
    escape : function(a) {
        return a.replace(Ext.util.Format.escapeRe, "\\$1")
    },
    toggle : function(b, c, a) {
        return b == c ? a : c
    },
    trim : function(a) {
        return a.replace(Ext.util.Format.trimRe, "")
    },
    leftPad : function(d, b, c) {
        var a = String(d);
        c = c || " ";
        while (a.length < b) {
            a = c + a
        }
        return a
    },
    format : function(b) {
        var a = Ext.toArray(arguments, 1);
        return b.replace(Ext.util.Format.formatRe, function(c, d) {
            return a[d]
        })
    },
    htmlEncode : function(a) {
        return !a ? a : String(a).replace(/&/g, "&amp;").replace(/>/g, "&gt;")
                .replace(/</g, "&lt;").replace(/"/g, "&quot;")
    },
    htmlDecode : function(a) {
        return !a ? a : String(a).replace(/&gt;/g, ">").replace(/&lt;/g, "<")
                .replace(/&quot;/g, '"').replace(/&amp;/g, "&")
    },
    date : function(a, b) {
        if (!a) {
            return ""
        }
        if (!Ext.isDate(a)) {
            a = new Date(Date.parse(a))
        }
        return a.dateFormat(b || Ext.util.Format.defaultDateFormat)
    }
};
Ext.LoadMask = Ext.extend(Ext.util.Observable, {
    msg : "Loading...",
    msgCls : "x-mask-loading",
    disabled : false,
    constructor : function(b, a) {
        this.el = Ext.get(b);
        Ext.apply(this, a);
        this.addEvents("show", "hide");
        if (this.store) {
            this.bindStore(this.store, true)
        }
        Ext.LoadMask.superclass.constructor.call(this)
    },
    bindStore : function(a, b) {
        if (!b && this.store) {
            this.mun(this.store, {
                scope : this,
                beforeload : this.onBeforeLoad,
                load : this.onLoad,
                exception : this.onLoad
            });
            if (!a) {
                this.store = null
            }
        }
        if (a) {
            a = Ext.StoreMgr.lookup(a);
            this.mon(a, {
                scope : this,
                beforeload : this.onBeforeLoad,
                load : this.onLoad,
                exception : this.onLoad
            })
        }
        this.store = a;
        if (a && a.isLoading()) {
            this.onBeforeLoad()
        }
    },
    disable : function() {
        this.disabled = true
    },
    enable : function() {
        this.disabled = false
    },
    isDisabled : function() {
        return this.disabled
    },
    onLoad : function() {
        this.el.unmask();
        this.fireEvent("hide", this, this.el, this.store)
    },
    onBeforeLoad : function() {
        if (!this.disabled) {
            this.el.mask(Ext.LoadingSpinner + '<div class="x-loading-msg">'
                    + this.msg + "</div>", this.msgCls, false);
            this.fireEvent("show", this, this.el, this.store)
        }
    },
    show : function() {
        this.onBeforeLoad()
    },
    hide : function() {
        this.onLoad()
    },
    destroy : function() {
        this.hide();
        this.clearListeners()
    }
});
Ext.LoadingSpinner = '<div class="x-loading-spinner"><span class="x-loading-top"></span><span class="x-loading-right"></span><span class="x-loading-bottom"></span><span class="x-loading-left"></span></div>';
Ext.applyIf(Array.prototype, {
    indexOf : function(b, c) {
        var a = this.length;
        c = c || 0;
        c += (c < 0) ? a : 0;
        for (; c < a; ++c) {
            if (this[c] === b) {
                return c
            }
        }
        return -1
    },
    remove : function(b) {
        var a = this.indexOf(b);
        if (a != -1) {
            this.splice(a, 1)
        }
        return this
    },
    contains : function(a) {
        return this.indexOf(a) !== -1
    }
});
Ext.ComponentMgr = new Ext.AbstractManager(
        {
            typeName : "xtype",
            create : function(b, d) {
                if (b.isComponent) {
                    return b
                } else {
                    var c = b.xtype || d, a = this.types[c];
                    if (!a) {
                        throw "Attempting to create a component with an xtype that has not been registered: "
                                + c
                    }
                    return new a(b)
                }
                return b.render ? b : new (b)
            },
            registerType : function(b, a) {
                this.types[b] = a;
                a[this.typeName] = b;
                a.prototype[this.typeName] = b
            }
        });
Ext.reg = function() {
    return Ext.ComponentMgr.registerType.apply(Ext.ComponentMgr, arguments)
};
Ext.create = function() {
    return Ext.ComponentMgr.create.apply(Ext.ComponentMgr, arguments)
};
Ext.ComponentQuery = new function() {
    var g = this, j = [ "var r = [],", "i = 0,", "it = arguments[0],",
            "l = it.length,", "c;", "for (; i < l; i++) {", "c = it[i].{0};",
            "if (c) {", "r.push(c);", "}", "}", "return r;" ].join(""), e = function(
            o, n) {
        return n.method.apply(this, [ o ].concat(n.args))
    }, a = function(p, u) {
        var n = [], q, t = p.length, s, o = u != ">";
        for (q = 0; q < t; q++) {
            s = p[q];
            if (s.getRefItems) {
                n = n.concat(s.getRefItems(o))
            }
        }
        return n
    }, f = function(o) {
        var n = [], p, s = o.length, q;
        for (p = 0; p < s; p++) {
            q = o[p];
            while (!!(q = q.ownerCt)) {
                n.push(q)
            }
        }
        return n
    }, l = function(o, u, t) {
        if (u == "*") {
            return o.slice()
        } else {
            var n = [], p, s = o.length, q;
            for (p = 0; p < s; p++) {
                q = o[p];
                if (q.isXType(u, t)) {
                    n.push(q)
                }
            }
            return n
        }
    }, i = function(o, s) {
        var n = [], p, t = o.length, q;
        for (p = 0; p < t; p++) {
            q = o[p];
            if (q.el ? q.el.hasCls(s) : q.initCls().contains(s)) {
                n.push(q)
            }
        }
        return n
    }, m = function(p, v, o, u) {
        var n = [], q, t = p.length, s;
        for (q = 0; q < t; q++) {
            s = p[q];
            if ((u === undefined) ? !!s[v] : (s[v] == u)) {
                n.push(s)
            }
        }
        return n
    }, d = function(o, t) {
        var n = [], p, s = o.length, q;
        for (p = 0; p < s; p++) {
            q = o[p];
            if (q.getItemId() == t) {
                n.push(q)
            }
        }
        return n
    }, k = function(n, o, p) {
        return g.pseudos[o](n, p)
    }, h = /^(\s?([>\^])\s?|\s|$)/, c = /^(?:(#)?([\w-]+|\*)(?:\((true|false)\))?)|(?:\{([^\}]+)\})/, b = [
            {
                re : /^\.([\w-]+)(?:\((true|false)\))?/,
                method : l
            },
            {
                re : /^(?:[\[\{](?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,
                method : m
            }, {
                re : /^#([\w-]+)/,
                method : d
            }, {
                re : /^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,
                method : k
            } ];
    g.Query = Ext.extend(Object, {
        constructor : function(n) {
            n = n || {};
            Ext.apply(this, n)
        },
        execute : function(o) {
            var q = this.operations, t = q.length, p, s, n;
            if (!o) {
                n = Ext.ComponentMgr.all.getArray()
            }
            for (s = 0; s < t; s++) {
                p = q[s];
                if (p.mode == "^") {
                    n = f(n || [ o ])
                } else {
                    if (p.mode) {
                        n = a(n || [ o ], p.mode)
                    } else {
                        n = e(n || a([ o ]), p)
                    }
                }
                if (s == t - 1) {
                    return n
                }
            }
            return []
        },
        is : function(p) {
            var o = this.operations, s = o.length, q, n = Ext.isArray(p) ? p
                    : [ p ];
            for (q = 0; q < s && n.length; q++) {
                n = e(n, o[q])
            }
            return n.length != 0
        }
    });
    Ext
            .apply(
                    this,
                    {
                        cache : {},
                        pseudos : {},
                        query : function(n, w) {
                            var x = n.split(","), q = x.length, o, t, p = [], y = [], v = {}, s, u;
                            for (o = 0; o < q; o++) {
                                n = Ext.util.Format.trim(x[o]);
                                t = this.cache[n];
                                if (!t) {
                                    this.cache[n] = t = this.parse(n)
                                }
                                p = p.concat(t.execute(w))
                            }
                            if (q > 1) {
                                s = p.length;
                                for (o = 0; o < s; o++) {
                                    u = p[o];
                                    if (!v[u.id]) {
                                        y.push(u);
                                        v[u.id] = true
                                    }
                                }
                                p = y
                            }
                            return p
                        },
                        is : function(o, n) {
                            if (!n) {
                                return true
                            }
                            var p = this.cache[n];
                            if (!p) {
                                this.cache[n] = p = this.parse(n)
                            }
                            return p.is(o)
                        },
                        parse : function(o) {
                            var n = [], u = b.length, v, p, w, x, y, t, q, s;
                            while (o && v != o) {
                                v = o;
                                p = o.match(c);
                                if (p) {
                                    w = p[1];
                                    if (w == "#") {
                                        n
                                                .push({
                                                    method : d,
                                                    args : [ Ext.util.Format
                                                            .trim(p[2]) ]
                                                })
                                    } else {
                                        if (w == ".") {
                                            n.push({
                                                method : i,
                                                args : [ Ext.util.Format
                                                        .trim(p[2]) ]
                                            })
                                        } else {
                                            if (p[4]) {
                                                n
                                                        .push({
                                                            method : new Function(
                                                                    Ext.util.Format
                                                                            .format(
                                                                                    j,
                                                                                    p[4])),
                                                            args : []
                                                        })
                                            } else {
                                                n
                                                        .push({
                                                            method : l,
                                                            args : [
                                                                    Ext.util.Format
                                                                            .trim(p[2]),
                                                                    Boolean(p[3]) ]
                                                        })
                                            }
                                        }
                                    }
                                    o = o.replace(p[0], "")
                                }
                                while (!(x = o.match(h))) {
                                    for (q = 0; o && q < u; q++) {
                                        s = b[q];
                                        y = o.match(s.re);
                                        if (y) {
                                            n.push({
                                                method : s.method,
                                                args : y.splice(1)
                                            });
                                            o = o.replace(y[0], "");
                                            break
                                        }
                                        if (q == (u - 1)) {
                                            throw 'Invalid ComponentQuery selector: "'
                                                    + arguments[0] + '"'
                                        }
                                    }
                                }
                                if (x[1]) {
                                    n.push({
                                        mode : x[2] || x[1]
                                    });
                                    o = o.replace(x[0], "")
                                }
                            }
                            return new g.Query({
                                operations : n
                            })
                        }
                    })
};
Ext.PluginMgr = new Ext.AbstractManager({
    typeName : "ptype",
    create : function(b, c) {
        var a = this.types[b.ptype || c];
        if (a.init) {
            return a
        } else {
            return new a(b)
        }
    },
    findByType : function(c, f) {
        var e = [], b = this.types;
        for ( var a in b) {
            if (!b.hasOwnProperty(a)) {
                continue
            }
            var d = b[a];
            if (d.type == c && (!f || (f === true && d.isDefault))) {
                e.push(d)
            }
        }
        return e
    }
});
Ext.preg = function() {
    return Ext.PluginMgr.registerType.apply(Ext.PluginMgr, arguments)
};
Ext.EventManager = {
    optionsRe : /^(?:capture|scope|delay|buffer|single|stopEvent|disableLocking|preventDefault|stopPropagation|normalized|args|delegate|horizontal|vertical|dragThreshold|holdThreshold|doubleTapThreshold|cancelThreshold|singleTapThreshold|fireClickEvent)$/,
    touchRe : /^(?:pinch|pinchstart|pinchend|tap|singletap|doubletap|swipe|swipeleft|swiperight|drag|dragstart|dragend|touchdown|touchstart|touchmove|touchend|taphold|tapstart|tapcancel)$/i,
    addListener : function(b, a, e, d, g) {
        if (Ext.isObject(a)) {
            this.handleListenerConfig(b, a);
            return
        }
        var f = Ext.getDom(b);
        if (!f) {
            throw 'Error listening for "' + a + '". Element "' + b
                    + "\" doesn't exist."
        }
        if (!e) {
            throw 'Error listening for "' + a
                    + '". No handler function specified'
        }
        var h = this.touchRe.test(a);
        var c = this.createListenerWrap(f, a, e, d, g, h);
        this.getEventListenerCache(f, a).push({
            fn : e,
            wrap : c,
            scope : d
        });
        if (h) {
            Ext.gesture.Manager.addEventListener(f, a, c, g)
        } else {
            g = g || {};
            f.addEventListener(a, c, g.capture || false)
        }
    },
    removeListener : function(g, k, l, m) {
        if (Ext.isObject(k)) {
            this.handleListenerConfig(g, k, true);
            return
        }
        var e = Ext.getDom(g), a = this.getEventListenerCache(e, k), h = a.length, f, c, b, d;
        while (h--) {
            c = a[h];
            if (c && (!l || c.fn == l) && (!m || c.scope === m)) {
                b = c.wrap;
                if (b.task) {
                    clearTimeout(b.task);
                    delete b.task
                }
                f = b.tasks && b.tasks.length;
                if (f) {
                    while (f--) {
                        clearTimeout(b.tasks[f])
                    }
                    delete b.tasks
                }
                if (this.touchRe.test(k)) {
                    Ext.gesture.Manager.removeEventListener(e, k, b)
                } else {
                    e.removeEventListener(k, b, false)
                }
                a.splice(h, 1)
            }
        }
    },
    removeAll : function(b) {
        var d = Ext.getDom(b), a = this.getElementEventCache(d), c;
        for (c in a) {
            if (!a.hasOwnProperty(c)) {
                continue
            }
            this.removeListener(d, c)
        }
        Ext.cache[d.id].events = {}
    },
    purgeElement : function(d, e, b) {
        var f = Ext.getDom(d), c = 0, a;
        if (b) {
            this.removeListener(f, b)
        } else {
            this.removeAll(f)
        }
        if (e && f && f.childNodes) {
            for (a = d.childNodes.length; c < a; c++) {
                this.purgeElement(d.childNodes[c], e, b)
            }
        }
    },
    handleListenerConfig : function(d, b, a) {
        var c, e;
        for (c in b) {
            if (!b.hasOwnProperty(c)) {
                continue
            }
            if (!this.optionsRe.test(c)) {
                e = b[c];
                if (Ext.isFunction(e)) {
                    this[(a ? "remove" : "add") + "Listener"](d, c, e, b.scope,
                            b)
                } else {
                    this[(a ? "remove" : "add") + "Listener"](d, c, b.fn,
                            b.scope, b)
                }
            }
        }
    },
    getId : function(a) {
        var b = false, c;
        a = Ext.getDom(a);
        if (a === document || a === window) {
            b = true
        }
        c = Ext.id(a);
        if (!Ext.cache[c]) {
            Ext.Element.addToCache(new Ext.Element(a), c);
            if (b) {
                Ext.cache[c].skipGarbageCollection = true
            }
        }
        return c
    },
    createListenerWrap : function(h, a, c, b, g, i) {
        g = !Ext.isObject(g) ? {} : g;
        var d = [ "if(!window.Ext) {return;}" ];
        if (i) {
            d.push("e = new Ext.TouchEventObjectImpl(e, args);")
        } else {
            if (g.buffer || g.delay) {
                d.push("e = new Ext.EventObjectImpl(e);")
            } else {
                d.push("e = Ext.EventObject.setEvent(e);")
            }
        }
        if (g.delegate) {
            d.push('var t = e.getTarget("' + g.delegate + '", this);');
            d.push("if(!t) {return;}")
        } else {
            d.push("var t = e.target;")
        }
        if (g.target) {
            d.push("if(e.target !== o.target) {return;}")
        }
        if (g.stopEvent) {
            d.push("e.stopEvent();")
        } else {
            if (g.preventDefault) {
                d.push("e.preventDefault();")
            }
            if (g.stopPropagation) {
                d.push("e.stopPropagation();")
            }
        }
        if (g.normalized === false) {
            d.push("e = e.browserEvent;")
        }
        if (g.buffer) {
            d.push("(wrap.task && clearTimeout(wrap.task));");
            d.push("wrap.task = setTimeout(function(){")
        }
        if (g.delay) {
            d.push("wrap.tasks = wrap.tasks || [];");
            d.push("wrap.tasks.push(setTimeout(function(){")
        }
        d.push("fn.call(scope || dom, e, t, o);");
        if (g.single) {
            d.push("Ext.EventManager.removeListener(dom, ename, fn, scope);")
        }
        if (g.delay) {
            d.push("}, " + g.delay + "));")
        }
        if (g.buffer) {
            d.push("}, " + g.buffer + ");")
        }
        var e = new Function("e", "o", "fn", "scope", "ename", "dom", "wrap",
                "args", d.join("\n"));
        return function(j, f) {
            e.call(h, j, g, c, b, a, h, arguments.callee, f)
        }
    },
    getEventListenerCache : function(c, a) {
        var b = this.getElementEventCache(c);
        return b[a] || (b[a] = [])
    },
    getElementEventCache : function(b) {
        var a = Ext.cache[this.getId(b)];
        return a.events || (a.events = {})
    },
    onDocumentReady : function(d, c, b) {
        var f = this, g = f.readyEvent, e;
        if (Ext.isReady) {
            g || (g = new Ext.util.Event());
            g.addListener(d, c, b);
            g.fire();
            g.listeners = []
        } else {
            if (!g) {
                g = f.readyEvent = new Ext.util.Event();
                var a = function() {
                    Ext.isReady = true;
                    window.removeEventListener("load", arguments.callee, false);
                    if (e) {
                        clearInterval(e)
                    }
                    setTimeout(function() {
                        Ext.supports.init();
                        Ext.gesture.Manager.init();
                        Ext.orientation = Ext.Element.getOrientation();
                        g.fire({
                            orientation : Ext.orientation,
                            width : Ext.Element.getViewportWidth(),
                            height : Ext.Element.getViewportHeight()
                        });
                        g.listeners = []
                    }, 50)
                };
                e = setInterval(function() {
                    if (/loaded|complete/.test(document.readyState)) {
                        clearInterval(e);
                        e = null;
                        a()
                    }
                }, 10);
                window.addEventListener("load", a, false)
            }
            b = b || {};
            b.delay = b.delay || 1;
            g.addListener(d, c, b)
        }
    },
    onWindowResize : function(c, b, a) {
        var e = this, f = e.resizeEvent;
        if (!f) {
            e.resizeEvent = f = new Ext.util.Event();
            var d = function() {
                f.fire(Ext.Element.getViewportWidth(), Ext.Element
                        .getViewportHeight())
            };
            this.addListener(window, "resize", d, this)
        }
        f.addListener(c, b, a)
    },
    onOrientationChange : function(c, b, a) {
        var e = this, d = e.orientationEvent;
        if (!d) {
            e.orientationEvent = d = new Ext.util.Event();
            var f = function(g, h) {
                Ext.orientation = Ext.Viewport.getOrientation();
                d.fire(Ext.orientation, h.width, h.height)
            };
            Ext.Viewport.on("resize", f, this)
        }
        d.addListener(c, b, a)
    },
    unOrientationChange : function(c, b, a) {
        var e = this, d = e.orientationEvent;
        if (d) {
            d.removeListener(c, b, a)
        }
    }
};
Ext.EventManager.on = Ext.EventManager.addListener;
Ext.EventManager.un = Ext.EventManager.removeListener;
Ext.onReady = Ext.EventManager.onDocumentReady;
Ext.EventObjectImpl = Ext.extend(Object, {
    constructor : function(a) {
        if (a) {
            this.setEvent(a.browserEvent || a)
        }
    },
    setEvent : function(c) {
        var b = this;
        if (c == b || (c && c.browserEvent)) {
            return c
        }
        b.browserEvent = c;
        if (c) {
            b.type = c.type;
            var a = c.target;
            b.target = a && a.nodeType == 3 ? a.parentNode : a;
            b.xy = [ c.pageX, c.pageY ];
            b.timestamp = c.timeStamp
        } else {
            b.target = null;
            b.xy = [ 0, 0 ]
        }
        return b
    },
    stopEvent : function() {
        this.stopPropagation();
        this.preventDefault()
    },
    preventDefault : function() {
        if (this.browserEvent) {
            this.browserEvent.preventDefault()
        }
    },
    stopPropagation : function() {
        if (this.browserEvent) {
            this.browserEvent.stopPropagation()
        }
    },
    getPageX : function() {
        return this.xy[0]
    },
    getPageY : function() {
        return this.xy[1]
    },
    getXY : function() {
        return this.xy
    },
    getTarget : function(b, c, a) {
        return b ? Ext.fly(this.target).findParent(b, c, a) : (a ? Ext
                .get(this.target) : this.target)
    },
    getTime : function() {
        return this.timestamp
    }
});
Ext.EventObject = new Ext.EventObjectImpl();
Ext.is = {
    init : function(b) {
        var f = this, c = f.platforms, e = c.length, d, a;
        b = b || window.navigator;
        for (d = 0; d < e; d++) {
            a = c[d];
            f[a.identity] = a.regex.test(b[a.property])
        }
        f.Desktop = f.Mac || f.Windows || (f.Linux && !f.Android);
        f.iOS = f.iPhone || f.iPad || f.iPod;
        f.Standalone = !!b.standalone;
        d = f.Android && (/Android\s(\d+\.\d+)/.exec(b.userAgent));
        if (d) {
            f.AndroidVersion = d[1];
            f.AndroidMajorVersion = parseInt(d[1], 10)
        }
        f.Tablet = f.iPad || (f.Android && f.AndroidMajorVersion === 3);
        f.Phone = !f.Desktop && !f.Tablet;
        f.MultiTouch = !f.Blackberry && !f.Desktop
                && !(f.Android && f.AndroidVersion < 3)
    },
    platforms : [ {
        property : "platform",
        regex : /iPhone/i,
        identity : "iPhone"
    }, {
        property : "platform",
        regex : /iPod/i,
        identity : "iPod"
    }, {
        property : "userAgent",
        regex : /iPad/i,
        identity : "iPad"
    }, {
        property : "userAgent",
        regex : /Blackberry/i,
        identity : "Blackberry"
    }, {
        property : "userAgent",
        regex : /Android/i,
        identity : "Android"
    }, {
        property : "platform",
        regex : /Mac/i,
        identity : "Mac"
    }, {
        property : "platform",
        regex : /Win/i,
        identity : "Windows"
    }, {
        property : "platform",
        regex : /Linux/i,
        identity : "Linux"
    } ]
};
Ext.is.init();
Ext.supports = {
    init : function() {
        var d = document, f = d.createElement("div"), b = this.tests, c = b.length, a, e;
        f.innerHTML = [ '<div style="height:30px;width:50px;">',
                '<div style="height:20px;width:20px;"></div>', "</div>",
                '<div style="float:left; background-color:transparent;"></div>' ]
                .join("");
        d.body.appendChild(f);
        for (a = 0; a < c; a++) {
            e = b[a];
            this[e.identity] = e.fn.call(this, d, f)
        }
        d.body.removeChild(f)
    },
    OrientationChange : ((typeof window.orientation != "undefined") && ("onorientationchange" in window)),
    DeviceMotion : ("ondevicemotion" in window),
    Touch : ("ontouchstart" in window) && (!Ext.is.Desktop),
    tests : [
            {
                identity : "Transitions",
                fn : function(f, h) {
                    var e = [ "webkit", "Moz", "o", "ms", "khtml" ], g = "TransitionEnd", a = [
                            e[0] + g, "transitionend", e[2] + g, e[3] + g,
                            e[4] + g ], d = e.length, c = 0, b = false;
                    h = Ext.get(h);
                    for (; c < d; c++) {
                        if (h.getStyle(e[c] + "TransitionProperty")) {
                            Ext.supports.CSS3Prefix = e[c];
                            Ext.supports.CSS3TransitionEnd = a[c];
                            b = true;
                            break
                        }
                    }
                    return b
                }
            },
            {
                identity : "RightMargin",
                fn : function(b, c, a) {
                    a = b.defaultView;
                    return !(a && a.getComputedStyle(c.firstChild.firstChild,
                            null).marginRight != "0px")
                }
            },
            {
                identity : "TransparentColor",
                fn : function(b, c, a) {
                    a = b.defaultView;
                    return !(a && a.getComputedStyle(c.lastChild, null).backgroundColor != "transparent")
                }
            },
            {
                identity : "SVG",
                fn : function(a) {
                    return !!a.createElementNS
                            && !!a.createElementNS(
                                    "http://www.w3.org/2000/svg", "svg").createSVGRect
                }
            },
            {
                identity : "Canvas",
                fn : function(a) {
                    return !!a.createElement("canvas").getContext
                }
            },
            {
                identity : "VML",
                fn : function(a) {
                    var b = a.createElement("div");
                    b.innerHTML = "<!--[if vml]><br><br><![endif]-->";
                    return (b.childNodes.length == 2)
                }
            },
            {
                identity : "Float",
                fn : function(a, b) {
                    return !!b.lastChild.style.cssFloat
                }
            },
            {
                identity : "AudioTag",
                fn : function(a) {
                    return !!a.createElement("audio").canPlayType
                }
            },
            {
                identity : "History",
                fn : function() {
                    return !!(window.history && history.pushState)
                }
            },
            {
                identity : "CSS3DTransform",
                fn : function() {
                    return (typeof WebKitCSSMatrix != "undefined" && new WebKitCSSMatrix()
                            .hasOwnProperty("m41"))
                }
            },
            {
                identity : "CSS3LinearGradient",
                fn : function(e, g) {
                    var d = "background-image:", b = "-webkit-gradient(linear, left top, right bottom, from(black), to(white))", f = "linear-gradient(left top, black, white)", c = "-moz-"
                            + f, a = [ d + b, d + f, d + c ];
                    g.style.cssText = a.join(";");
                    return ("" + g.style.backgroundImage).indexOf("gradient") !== -1
                }
            },
            {
                identity : "CSS3BorderRadius",
                fn : function(d, e) {
                    var b = [ "borderRadius", "BorderRadius",
                            "MozBorderRadius", "WebkitBorderRadius",
                            "OBorderRadius", "KhtmlBorderRadius" ], c = false, a;
                    for (a = 0; a < b.length; a++) {
                        if (document.body.style[b[a]] !== undefined) {
                            return c = true
                        }
                    }
                    return c
                }
            },
            {
                identity : "GeoLocation",
                fn : function() {
                    return (typeof navigator != "undefined" && typeof navigator.geolocation != "undefined")
                            || (typeof google != "undefined" && typeof google.gears != "undefined")
                }
            } ]
};
Ext.data.Batch = Ext.extend(Ext.util.Observable, {
    autoStart : false,
    current : -1,
    total : 0,
    isRunning : false,
    isComplete : false,
    hasException : false,
    pauseOnException : true,
    constructor : function(a) {
        this.addEvents("complete", "exception", "operationcomplete",
                "operation-complete");
        Ext.data.Batch.superclass.constructor.call(this, a);
        this.operations = []
    },
    add : function(a) {
        this.total++;
        a.setBatch(this);
        this.operations.push(a)
    },
    start : function() {
        this.hasException = false;
        this.isRunning = true;
        this.runNextOperation()
    },
    runNextOperation : function() {
        this.runOperation(this.current + 1)
    },
    pause : function() {
        this.isRunning = false
    },
    runOperation : function(d) {
        var c = this.operations, b = c[d];
        if (b == undefined) {
            this.isRunning = false;
            this.isComplete = true;
            this.fireEvent("complete", this, c[c.length - 1])
        } else {
            this.current = d;
            var a = function(e) {
                var f = e.hasException();
                if (f) {
                    this.hasException = true;
                    this.fireEvent("exception", this, e)
                } else {
                    this.fireEvent("operation-complete", this, e);
                    this.fireEvent("operationcomplete", this, e)
                }
                if (f && this.pauseOnException) {
                    this.pause()
                } else {
                    e.setCompleted();
                    this.runNextOperation()
                }
            };
            b.setStarted();
            this.proxy[b.action](b, a, this)
        }
    }
});
Ext.data.Model = Ext
        .extend(
                Ext.util.Stateful,
                {
                    evented : false,
                    isModel : true,
                    phantom : false,
                    idProperty : "id",
                    constructor : function(e, g) {
                        e = e || {};
                        this.internalId = (g || g === 0) ? g : Ext.data.Model
                                .id(this);
                        Ext.data.Model.superclass.constructor.apply(this);
                        var a = this.fields.items, d = a.length, f, b, c;
                        for (c = 0; c < d; c++) {
                            f = a[c];
                            b = f.name;
                            if (e[b] == undefined) {
                                e[b] = f.defaultValue
                            }
                        }
                        this.set(e);
                        this.dirty = false;
                        if (this.getId()) {
                            this.phantom = false
                        }
                        if (typeof this.init == "function") {
                            this.init()
                        }
                    },
                    validate : function() {
                        var j = new Ext.data.Errors(), c = this.validations, e = Ext.data.validations, b, d, h, a, g, f;
                        if (c) {
                            b = c.length;
                            for (f = 0; f < b; f++) {
                                d = c[f];
                                h = d.field || d.name;
                                g = d.type;
                                a = e[g](d, this.get(h));
                                if (!a) {
                                    j.add({
                                        field : h,
                                        message : d.message || e[g + "Message"]
                                    })
                                }
                            }
                        }
                        return j
                    },
                    getProxy : function() {
                        return this.constructor.proxy
                    },
                    save : function(j) {
                        var f = this, a = f.phantom ? "create" : "update";
                        j = j || {};
                        Ext.apply(j, {
                            records : [ f ],
                            action : a
                        });
                        var b = new Ext.data.Operation(j), h = j.success, d = j.failure, e = j.callback, i = j.scope, c;
                        var g = function(k) {
                            c = k.getRecords()[0];
                            if (k.wasSuccessful()) {
                                f.set(c.data);
                                c.dirty = false;
                                if (typeof h == "function") {
                                    h.call(i, c, k)
                                }
                            } else {
                                if (typeof d == "function") {
                                    d.call(i, c, k)
                                }
                            }
                            if (typeof e == "function") {
                                e.call(i, c, k)
                            }
                        };
                        f.getProxy()[a](b, g, f);
                        return f
                    },
                    getId : function() {
                        return this.get(this.idProperty)
                    },
                    setId : function(a) {
                        this.set(this.idProperty, a)
                    },
                    join : function(a) {
                        this.store = a
                    },
                    unjoin : function(a) {
                        delete this.store
                    },
                    afterEdit : function() {
                        this.callStore("afterEdit")
                    },
                    afterReject : function() {
                        this.callStore("afterReject")
                    },
                    afterCommit : function() {
                        this.callStore("afterCommit")
                    },
                    callStore : function(b) {
                        var a = this.store;
                        if (a != undefined && typeof a[b] == "function") {
                            a[b](this)
                        }
                    }
                });
Ext
        .apply(
                Ext.data.Model,
                {
                    setProxy : function(a) {
                        a = Ext.data.ProxyMgr.create(a);
                        a.setModel(this);
                        this.proxy = a;
                        return a
                    },
                    load : function(a, b) {
                        b = Ext.applyIf(b || {}, {
                            action : "read",
                            id : a
                        });
                        var c = new Ext.data.Operation(b), f = b.callback, h = b.success, e = b.failure, i = b.scope, d, g;
                        g = function(j) {
                            d = j.getRecords()[0];
                            if (j.wasSuccessful()) {
                                if (typeof h == "function") {
                                    h.call(i, d, j)
                                }
                            } else {
                                if (typeof e == "function") {
                                    e.call(i, d, j)
                                }
                            }
                            if (typeof f == "function") {
                                f.call(i, d, j)
                            }
                        };
                        this.proxy.read(c, g, this)
                    }
                });
Ext.data.Model.id = function(a) {
    a.phantom = true;
    return [ Ext.data.Model.PREFIX, "-", Ext.data.Model.AUTO_ID++ ].join("")
};
Ext.ns("Ext.data.Record");
Ext.data.Record.id = Ext.data.Model.id;
Ext.data.Model.PREFIX = "ext-record";
Ext.data.Model.AUTO_ID = 1;
Ext.data.Model.EDIT = "edit";
Ext.data.Model.REJECT = "reject";
Ext.data.Model.COMMIT = "commit";
Ext.data.Association = Ext
        .extend(
                Object,
                {
                    primaryKey : "id",
                    constructor : function(b) {
                        Ext.apply(this, b);
                        var c = Ext.ModelMgr.types, d = b.ownerModel, f = b.associatedModel, e = c[d], g = c[f], a;
                        if (e == undefined) {
                            throw new Error(
                                    "The configured ownerModel was not valid (you tried "
                                            + d + ")")
                        }
                        if (g == undefined) {
                            throw new Error(
                                    "The configured associatedModel was not valid (you tried "
                                            + f + ")")
                        }
                        this.ownerModel = e;
                        this.associatedModel = g;
                        Ext.applyIf(this, {
                            ownerName : d,
                            associatedName : f
                        })
                    }
                });
Ext.data.HasManyAssociation = Ext
        .extend(
                Ext.data.Association,
                {
                    constructor : function(c) {
                        Ext.data.HasManyAssociation.superclass.constructor
                                .apply(this, arguments);
                        var a = this.ownerModel.prototype, b = this.name;
                        Ext.applyIf(this, {
                            storeName : b + "Store",
                            foreignKey : this.ownerName.toLowerCase() + "_id"
                        });
                        a[b] = this.createStore()
                    },
                    createStore : function() {
                        var f = this.associatedModel, b = this.storeName, c = this.foreignKey, a = this.primaryKey, e = this.filterProperty, d = this.storeConfig
                                || {};
                        return function() {
                            var j = this, h, i, g = {};
                            if (j[b] == undefined) {
                                if (e) {
                                    i = {
                                        property : e,
                                        value : j.get(e),
                                        exactMatch : true
                                    }
                                } else {
                                    i = {
                                        property : c,
                                        value : j.get(a),
                                        exactMatch : true
                                    }
                                }
                                g[c] = j.get(a);
                                h = Ext.apply({}, d, {
                                    model : f,
                                    filters : [ i ],
                                    remoteFilter : false,
                                    modelDefaults : g
                                });
                                j[b] = new Ext.data.Store(h)
                            }
                            return j[b]
                        }
                    }
                });
Ext.data.BelongsToAssociation = Ext
        .extend(
                Ext.data.Association,
                {
                    constructor : function(c) {
                        Ext.data.BelongsToAssociation.superclass.constructor
                                .apply(this, arguments);
                        var e = this, a = e.ownerModel.prototype, f = e.associatedName, d = e.getterName
                                || "get" + f, b = e.setterName || "set" + f;
                        Ext.applyIf(e, {
                            name : f,
                            foreignKey : f.toLowerCase() + "_id",
                            instanceName : f + "BelongsToInstance"
                        });
                        a[d] = e.createGetter();
                        a[b] = e.createSetter()
                    },
                    createSetter : function() {
                        var c = this, d = c.ownerModel, e = c.associatedModel, b = c.foreignKey, a = c.primaryKey;
                        return function(h, f, g) {
                            this.set(b, h);
                            if (typeof f == "function") {
                                f = {
                                    callback : f,
                                    scope : g || this
                                }
                            }
                            if (Ext.isObject(f)) {
                                return this.save(f)
                            }
                        }
                    },
                    createGetter : function() {
                        var d = this, f = d.ownerModel, e = d.associatedName, g = d.associatedModel, c = d.foreignKey, b = d.primaryKey, a = d.instanceName;
                        return function(j, k) {
                            j = j || {};
                            var l = this.get(c), h, i;
                            if (this[a] == undefined) {
                                h = Ext.ModelMgr.create({}, e);
                                h.set(b, l);
                                if (typeof j == "function") {
                                    j = {
                                        callback : j,
                                        scope : k || this
                                    }
                                }
                                g.load(l, j)
                            } else {
                                h = this[a];
                                if (typeof j == "function") {
                                    j.call(k || this, h)
                                }
                                if (j.success) {
                                    j.success.call(k || this, h)
                                }
                                if (j.callback) {
                                    j.callback.call(k || this, h)
                                }
                                return h
                            }
                        }
                    }
                });
Ext.data.PolymorphicAssociation = Ext
        .extend(
                Ext.data.Association,
                {
                    constructor : function(c) {
                        Ext.data.PolymorphicAssociation.superclass.constructor
                                .call(this, c);
                        var a = this.ownerModel.prototype, b = this.name;
                        Ext.applyIf(this, {
                            associationIdField : this.ownerName.toLowerCase()
                                    + "_id"
                        });
                        a[b] = this.createStore()
                    },
                    createStore : function() {
                        var b = this, f = this.ownerName, d = this.name
                                + "Store", g = this.associatedModel, c = this.primaryKey, a = "associated_id", e = "associated_model";
                        return function() {
                            var k = this, h = {}, i, j;
                            if (k[d] == undefined) {
                                j = [ {
                                    property : a,
                                    value : k.get(c),
                                    exactMatch : true
                                }, {
                                    property : e,
                                    value : f,
                                    exactMatch : true
                                } ];
                                h[a] = k.get(c);
                                h[e] = f;
                                i = Ext.apply({}, b.storeConfig || {}, {
                                    model : g,
                                    filters : j,
                                    remoteFilter : false,
                                    modelDefaults : h
                                });
                                k[d] = new Ext.data.Store(i)
                            }
                            return k[d]
                        }
                    }
                });
Ext.data.validations = {
    presenceMessage : "must be present",
    lengthMessage : "is the wrong length",
    formatMessage : "is the wrong format",
    inclusionMessage : "is not included in the list of acceptable values",
    exclusionMessage : "is not an acceptable value",
    presence : function(a, b) {
        if (b == undefined) {
            b = a
        }
        return !!b
    },
    length : function(b, e) {
        if (e == undefined) {
            return false
        }
        var d = e.length, c = b.min, a = b.max;
        if ((c && d < c) || (a && d > a)) {
            return false
        } else {
            return true
        }
    },
    format : function(a, b) {
        return !!(a.matcher && a.matcher.test(b))
    },
    inclusion : function(a, b) {
        return a.list && a.list.indexOf(b) != -1
    },
    exclusion : function(a, b) {
        return a.list && a.list.indexOf(b) == -1
    }
};
Ext.data.Errors = Ext.extend(Ext.util.MixedCollection, {
    isValid : function() {
        return this.length == 0
    },
    getByField : function(e) {
        var d = [], a, c, b;
        for (b = 0; b < this.length; b++) {
            a = this.items[b];
            if (a.field == e) {
                d.push(a)
            }
        }
        return d
    }
});
Ext.data.Field = Ext.extend(Object, {
    constructor : function(b) {
        if (Ext.isString(b)) {
            b = {
                name : b
            }
        }
        Ext.apply(this, b);
        var d = Ext.data.Types, a = this.sortType, c;
        if (this.type) {
            if (Ext.isString(this.type)) {
                this.type = d[this.type.toUpperCase()] || d.AUTO
            }
        } else {
            this.type = d.AUTO
        }
        if (Ext.isString(a)) {
            this.sortType = Ext.data.SortTypes[a]
        } else {
            if (Ext.isEmpty(a)) {
                this.sortType = this.type.sortType
            }
        }
        if (!this.convert) {
            this.convert = this.type.convert
        }
    },
    dateFormat : null,
    useNull : false,
    defaultValue : "",
    mapping : null,
    sortType : null,
    sortDir : "ASC",
    allowBlank : true
});
Ext.data.SortTypes = {
    none : function(a) {
        return a
    },
    stripTagsRE : /<\/?[^>]+>/gi,
    asText : function(a) {
        return String(a).replace(this.stripTagsRE, "")
    },
    asUCText : function(a) {
        return String(a).toUpperCase().replace(this.stripTagsRE, "")
    },
    asUCString : function(a) {
        return String(a).toUpperCase()
    },
    asDate : function(a) {
        if (!a) {
            return 0
        }
        if (Ext.isDate(a)) {
            return a.getTime()
        }
        return Date.parse(String(a))
    },
    asFloat : function(a) {
        var b = parseFloat(String(a).replace(/,/g, ""));
        return isNaN(b) ? 0 : b
    },
    asInt : function(a) {
        var b = parseInt(String(a).replace(/,/g, ""), 10);
        return isNaN(b) ? 0 : b
    }
};
Ext.data.Types = new function() {
    var a = Ext.data.SortTypes;
    Ext.apply(this, {
        stripRe : /[\$,%]/g,
        AUTO : {
            convert : function(b) {
                return b
            },
            sortType : a.none,
            type : "auto"
        },
        STRING : {
            convert : function(b) {
                return (b === undefined || b === null) ? "" : String(b)
            },
            sortType : a.asUCString,
            type : "string"
        },
        INT : {
            convert : function(b) {
                return b !== undefined && b !== null && b !== "" ? parseInt(
                        String(b).replace(Ext.data.Types.stripRe, ""), 10)
                        : (this.useNull ? null : 0)
            },
            sortType : a.none,
            type : "int"
        },
        FLOAT : {
            convert : function(b) {
                return b !== undefined && b !== null && b !== "" ? parseFloat(
                        String(b).replace(Ext.data.Types.stripRe, ""), 10)
                        : (this.useNull ? null : 0)
            },
            sortType : a.none,
            type : "float"
        },
        BOOL : {
            convert : function(b) {
                return b === true || b === "true" || b == 1
            },
            sortType : a.none,
            type : "bool"
        },
        DATE : {
            convert : function(c) {
                var d = this.dateFormat;
                if (!c) {
                    return null
                }
                if (Ext.isDate(c)) {
                    return c
                }
                if (d) {
                    if (d == "timestamp") {
                        return new Date(c * 1000)
                    }
                    if (d == "time") {
                        return new Date(parseInt(c, 10))
                    }
                    return Date.parseDate(c, d)
                }
                var b = Date.parse(c);
                return b ? new Date(b) : null
            },
            sortType : a.asDate,
            type : "date"
        }
    });
    Ext.apply(this, {
        BOOLEAN : this.BOOL,
        INTEGER : this.INT,
        NUMBER : this.FLOAT
    })
};
Ext.ModelMgr = new Ext.AbstractManager(
        {
            typeName : "mtype",
            defaultProxyType : "ajax",
            associationStack : [],
            registerType : function(t, s) {
                var e = Ext.PluginMgr, l = e.findByType("model", true), k = s.fields
                        || [], p = s.associations || [], o = s.belongsTo, h = s.hasMany, q = s.extend, j = s.plugins
                        || [], b, c, d, n, f, a, g, m;
                if (o) {
                    if (!Ext.isArray(o)) {
                        o = [ o ]
                    }
                    for (n = 0; n < o.length; n++) {
                        b = o[n];
                        if (!Ext.isObject(b)) {
                            b = {
                                model : b
                            }
                        }
                        Ext.apply(b, {
                            type : "belongsTo"
                        });
                        p.push(b)
                    }
                    delete s.belongsTo
                }
                if (h) {
                    if (!Ext.isArray(h)) {
                        h = [ h ]
                    }
                    for (n = 0; n < h.length; n++) {
                        b = h[n];
                        if (!Ext.isObject(b)) {
                            b = {
                                model : b
                            }
                        }
                        Ext.apply(b, {
                            type : "hasMany"
                        });
                        p.push(b)
                    }
                    delete s.hasMany
                }
                if (q) {
                    f = this.types[q];
                    a = f.prototype;
                    g = a.validations;
                    m = f.proxy;
                    k = a.fields.items.concat(k);
                    p = a.associations.items.concat(p);
                    s.validations = g ? g.concat(s.validations) : s.validations
                } else {
                    f = Ext.data.Model;
                    m = s.proxy
                }
                c = Ext.extend(f, s);
                for (n = 0, d = j.length; n < d; n++) {
                    l.push(e.create(j[n]))
                }
                this.types[t] = c;
                Ext.override(c, {
                    plugins : l,
                    fields : this.createFields(k),
                    associations : this.createAssociations(p, t)
                });
                c.modelName = t;
                Ext.data.Model.setProxy.call(c, m || this.defaultProxyType);
                c.getProxy = c.prototype.getProxy;
                c.load = function() {
                    Ext.data.Model.load.apply(this, arguments)
                };
                for (n = 0, d = l.length; n < d; n++) {
                    l[n].bootstrap(c, s)
                }
                c.defined = true;
                this.onModelDefined(c);
                return c
            },
            onModelDefined : function(c) {
                var a = this.associationStack, f = a.length, e = [], b, d;
                for (d = 0; d < f; d++) {
                    b = a[d];
                    if (b.associatedModel == c.modelName) {
                        e.push(b)
                    }
                }
                f = e.length;
                for (d = 0; d < f; d++) {
                    this.addAssociation(e[d],
                            this.types[e[d].ownerModel].prototype.associations);
                    a.remove(e[d])
                }
            },
            createAssociations : function(e, b) {
                var f = e.length, d, c, a;
                c = new Ext.util.MixedCollection(false, function(g) {
                    return g.name
                });
                for (d = 0; d < f; d++) {
                    a = e[d];
                    Ext.apply(a, {
                        ownerModel : b,
                        associatedModel : a.model
                    });
                    if (this.types[a.model] == undefined) {
                        this.associationStack.push(a)
                    } else {
                        this.addAssociation(a, c)
                    }
                }
                return c
            },
            addAssociation : function(a, b) {
                var c = a.type;
                if (c == "belongsTo") {
                    b.add(new Ext.data.BelongsToAssociation(a))
                }
                if (c == "hasMany") {
                    b.add(new Ext.data.HasManyAssociation(a))
                }
                if (c == "polymorphic") {
                    b.add(new Ext.data.PolymorphicAssociation(a))
                }
            },
            createFields : function(a) {
                var d = a.length, c, b;
                b = new Ext.util.MixedCollection(false, function(e) {
                    return e.name
                });
                for (c = 0; c < d; c++) {
                    b.add(new Ext.data.Field(a[c]))
                }
                return b
            },
            getModel : function(b) {
                var a = b;
                if (typeof a == "string") {
                    a = this.types[a]
                }
                return a
            },
            create : function(c, b, d) {
                var a = typeof b == "function" ? b : this.types[b || c.name];
                return new a(c, d)
            }
        });
Ext.regModel = function() {
    return Ext.ModelMgr.registerType.apply(Ext.ModelMgr, arguments)
};
Ext.data.Operation = Ext
        .extend(
                Object,
                {
                    synchronous : true,
                    action : undefined,
                    filters : undefined,
                    sorters : undefined,
                    group : undefined,
                    start : undefined,
                    limit : undefined,
                    batch : undefined,
                    started : false,
                    running : false,
                    complete : false,
                    success : undefined,
                    exception : false,
                    error : undefined,
                    constructor : function(a) {
                        Ext.apply(this, a || {})
                    },
                    setStarted : function() {
                        this.started = true;
                        this.running = true
                    },
                    setCompleted : function() {
                        this.complete = true;
                        this.running = false
                    },
                    setSuccessful : function() {
                        this.success = true
                    },
                    setException : function(a) {
                        this.exception = true;
                        this.success = false;
                        this.running = false;
                        this.error = a
                    },
                    markStarted : function() {
                        console
                                .warn("Operation: markStarted has been deprecated. Please use setStarted");
                        return this.setStarted()
                    },
                    markCompleted : function() {
                        console
                                .warn("Operation: markCompleted has been deprecated. Please use setCompleted");
                        return this.setCompleted()
                    },
                    markSuccessful : function() {
                        console
                                .warn("Operation: markSuccessful has been deprecated. Please use setSuccessful");
                        return this.setSuccessful()
                    },
                    markException : function() {
                        console
                                .warn("Operation: markException has been deprecated. Please use setException");
                        return this.setException()
                    },
                    hasException : function() {
                        return this.exception === true
                    },
                    getError : function() {
                        return this.error
                    },
                    getRecords : function() {
                        var a = this.getResultSet();
                        return (a == undefined ? this.records : a.records)
                    },
                    getResultSet : function() {
                        return this.resultSet
                    },
                    isStarted : function() {
                        return this.started === true
                    },
                    isRunning : function() {
                        return this.running === true
                    },
                    isComplete : function() {
                        return this.complete === true
                    },
                    wasSuccessful : function() {
                        return this.isComplete() && this.success === true
                    },
                    setBatch : function(a) {
                        this.batch = a
                    },
                    allowWrite : function() {
                        return this.action != "read"
                    }
                });
Ext.data.ProxyMgr = new Ext.AbstractManager(
        {
            create : function(a) {
                if (a == undefined || typeof a == "string") {
                    a = {
                        type : a
                    }
                }
                if (!(a instanceof Ext.data.Proxy)) {
                    Ext.applyIf(a, {
                        type : this.defaultProxyType,
                        model : this.model
                    });
                    var b = a[this.typeName] || a.type, c = this.types[b];
                    if (c == undefined) {
                        throw new Error(
                                Ext.util.Format
                                        .format(
                                                "The '{0}' type has not been registered with this manager",
                                                b))
                    }
                    return new c(a)
                } else {
                    return a
                }
            }
        });
Ext.data.ReaderMgr = new Ext.AbstractManager({
    typeName : "rtype"
});
Ext.data.Request = Ext.extend(Object, {
    action : undefined,
    params : undefined,
    method : "GET",
    url : undefined,
    constructor : function(a) {
        Ext.apply(this, a)
    }
});
Ext.data.ResultSet = Ext.extend(Object, {
    loaded : true,
    count : 0,
    total : 0,
    success : false,
    constructor : function(a) {
        Ext.apply(this, a);
        this.totalRecords = this.total;
        if (a.count == undefined) {
            this.count = this.records.length
        }
    }
});
Ext.data.AbstractStore = Ext
        .extend(
                Ext.util.Observable,
                {
                    remoteSort : false,
                    remoteFilter : false,
                    autoLoad : false,
                    autoSave : false,
                    batchUpdateMode : "operation",
                    filterOnLoad : true,
                    sortOnLoad : true,
                    defaultSortDirection : "ASC",
                    implicitModel : false,
                    defaultProxyType : "memory",
                    isDestroyed : false,
                    isStore : true,
                    constructor : function(a) {
                        this.addEvents("add", "remove", "update",
                                "datachanged", "beforeload", "load",
                                "beforesync");
                        Ext.apply(this, a);
                        this.removed = [];
                        this.sortToggle = {};
                        Ext.data.AbstractStore.superclass.constructor.apply(
                                this, arguments);
                        this.model = Ext.ModelMgr.getModel(a.model);
                        Ext.applyIf(this, {
                            modelDefaults : {}
                        });
                        if (!this.model && a.fields) {
                            this.model = Ext.regModel("ImplicitModel-"
                                    + this.storeId || Ext.id(), {
                                fields : a.fields
                            });
                            delete this.fields;
                            this.implicitModel = true
                        }
                        this.setProxy(a.proxy || this.model.proxy);
                        if (this.id && !this.storeId) {
                            this.storeId = this.id;
                            delete this.id
                        }
                        if (this.storeId) {
                            Ext.StoreMgr.register(this)
                        }
                        this.sorters = new Ext.util.MixedCollection();
                        this.sorters.addAll(this.decodeSorters(a.sorters));
                        this.filters = new Ext.util.MixedCollection();
                        this.filters.addAll(this.decodeFilters(a.filters))
                    },
                    setProxy : function(a) {
                        if (a instanceof Ext.data.Proxy) {
                            a.setModel(this.model)
                        } else {
                            Ext.applyIf(a, {
                                model : this.model
                            });
                            a = Ext.data.ProxyMgr.create(a)
                        }
                        this.proxy = a;
                        return this.proxy
                    },
                    getProxy : function() {
                        return this.proxy
                    },
                    create : function(d, c) {
                        var a = Ext.ModelMgr.create(Ext.applyIf(d,
                                this.modelDefaults), this.model.modelName), b;
                        c = c || {};
                        Ext.applyIf(c, {
                            action : "create",
                            records : [ a ]
                        });
                        b = new Ext.data.Operation(c);
                        this.proxy.create(b, this.onProxyWrite, this);
                        return a
                    },
                    read : function() {
                        return this.load.apply(this, arguments)
                    },
                    onProxyRead : Ext.emptyFn,
                    update : function(b) {
                        b = b || {};
                        Ext.applyIf(b, {
                            action : "update",
                            records : this.getUpdatedRecords()
                        });
                        var a = new Ext.data.Operation(b);
                        return this.proxy.update(a, this.onProxyWrite, this)
                    },
                    onProxyWrite : Ext.emptyFn,
                    destroy : function(b) {
                        b = b || {};
                        Ext.applyIf(b, {
                            action : "destroy",
                            records : this.getRemovedRecords()
                        });
                        var a = new Ext.data.Operation(b);
                        return this.proxy.destroy(a, this.onProxyWrite, this)
                    },
                    onBatchOperationComplete : function(b, a) {
                        return this.onProxyWrite(a)
                    },
                    onBatchComplete : function(c, a) {
                        var b = c.operations, e = b.length, d;
                        this.suspendEvents();
                        for (d = 0; d < e; d++) {
                            this.onProxyWrite(b[d])
                        }
                        this.resumeEvents();
                        this.fireEvent("datachanged", this)
                    },
                    onBatchException : function(b, a) {
                    },
                    filterNew : function(a) {
                        return a.phantom == true || a.needsAdd == true
                    },
                    getNewRecords : function() {
                        return []
                    },
                    getUpdatedRecords : function() {
                        return []
                    },
                    filterDirty : function(a) {
                        return a.dirty == true
                    },
                    getRemovedRecords : function() {
                        return this.removed
                    },
                    sort : function(b, a) {
                    },
                    decodeSorters : function(d) {
                        if (!Ext.isArray(d)) {
                            if (d == undefined) {
                                d = []
                            } else {
                                d = [ d ]
                            }
                        }
                        var c = d.length, e = Ext.util.Sorter, a, b;
                        for (b = 0; b < c; b++) {
                            a = d[b];
                            if (!(a instanceof e)) {
                                if (Ext.isString(a)) {
                                    a = {
                                        property : a
                                    }
                                }
                                Ext.applyIf(a, {
                                    root : "data",
                                    direction : "ASC"
                                });
                                if (a.fn) {
                                    a.sorterFn = a.fn
                                }
                                if (typeof a == "function") {
                                    a = {
                                        sorterFn : a
                                    }
                                }
                                d[b] = new e(a)
                            }
                        }
                        return d
                    },
                    filter : function(a, b) {
                    },
                    createSortFunction : function(d, c) {
                        c = c || "ASC";
                        var b = c.toUpperCase() == "DESC" ? -1 : 1;
                        var a = this.model.prototype.fields, e = a.get(d).sortType;
                        return function(g, f) {
                            var i = e(g.data[d]), h = e(f.data[d]);
                            return b * (i > h ? 1 : (i < h ? -1 : 0))
                        }
                    },
                    decodeFilters : function(e) {
                        if (!Ext.isArray(e)) {
                            if (e == undefined) {
                                e = []
                            } else {
                                e = [ e ]
                            }
                        }
                        var d = e.length, a = Ext.util.Filter, b, c;
                        for (c = 0; c < d; c++) {
                            b = e[c];
                            if (!(b instanceof a)) {
                                Ext.apply(b, {
                                    root : "data"
                                });
                                if (b.fn) {
                                    b.filterFn = b.fn
                                }
                                if (typeof b == "function") {
                                    b = {
                                        filterFn : b
                                    }
                                }
                                e[c] = new a(b)
                            }
                        }
                        return e
                    },
                    clearFilter : function(a) {
                    },
                    isFiltered : function() {
                    },
                    filterBy : function(b, a) {
                    },
                    sync : function() {
                        var d = this, b = {}, e = d.getNewRecords(), c = d
                                .getUpdatedRecords(), a = d.getRemovedRecords(), f = false;
                        if (e.length > 0) {
                            b.create = e;
                            f = true
                        }
                        if (c.length > 0) {
                            b.update = c;
                            f = true
                        }
                        if (a.length > 0) {
                            b.destroy = a;
                            f = true
                        }
                        if (f && d.fireEvent("beforesync", b) !== false) {
                            d.proxy.batch(b, d.getBatchListeners())
                        }
                    },
                    getBatchListeners : function() {
                        var a = {
                            scope : this,
                            exception : this.onBatchException
                        };
                        if (this.batchUpdateMode == "operation") {
                            a.operationcomplete = this.onBatchOperationComplete
                        } else {
                            a.complete = this.onBatchComplete
                        }
                        return a
                    },
                    save : function() {
                        return this.sync.apply(this, arguments)
                    },
                    load : function(b) {
                        var c = this, a;
                        b = b || {};
                        Ext.applyIf(b, {
                            action : "read",
                            filters : c.filters.items,
                            sorters : c.sorters.items
                        });
                        a = new Ext.data.Operation(b);
                        if (c.fireEvent("beforeload", c, a) !== false) {
                            c.loading = true;
                            c.proxy.read(a, c.onProxyLoad, c)
                        }
                        return c
                    },
                    afterEdit : function(a) {
                        this.fireEvent("update", this, a, Ext.data.Model.EDIT)
                    },
                    afterReject : function(a) {
                        this
                                .fireEvent("update", this, a,
                                        Ext.data.Model.REJECT)
                    },
                    afterCommit : function(a) {
                        if (this.autoSave) {
                            this.sync()
                        }
                        this
                                .fireEvent("update", this, a,
                                        Ext.data.Model.COMMIT)
                    },
                    clearData : Ext.emptyFn,
                    destroyStore : function() {
                        if (!this.isDestroyed) {
                            if (this.storeId) {
                                Ext.StoreMgr.unregister(this)
                            }
                            this.clearData();
                            this.data = null;
                            this.tree = null;
                            this.reader = this.writer = null;
                            this.clearListeners();
                            this.isDestroyed = true;
                            if (this.implicitModel) {
                                Ext.destroy(this.model)
                            }
                        }
                    },
                    getSortState : function() {
                        return this.sortInfo
                    },
                    getCount : function() {
                    },
                    getById : function(a) {
                    },
                    removeAll : function() {
                    }
                });
Ext.data.Store = Ext
        .extend(
                Ext.data.AbstractStore,
                {
                    remoteSort : false,
                    remoteFilter : false,
                    groupField : undefined,
                    groupDir : "ASC",
                    pageSize : 25,
                    currentPage : 1,
                    clearOnPageLoad : true,
                    implicitModel : false,
                    loading : false,
                    sortOnFilter : true,
                    isStore : true,
                    constructor : function(a) {
                        a = a || {};
                        this.data = new Ext.util.MixedCollection(false,
                                function(d) {
                                    return d.internalId
                                });
                        if (a.data) {
                            this.inlineData = a.data;
                            delete a.data
                        }
                        Ext.data.Store.superclass.constructor.call(this, a);
                        var b = this.proxy, c = this.inlineData;
                        if (c) {
                            if (b instanceof Ext.data.MemoryProxy) {
                                b.data = c;
                                this.read()
                            } else {
                                this.add.apply(this, c)
                            }
                            this.sort();
                            delete this.inlineData
                        } else {
                            if (this.autoLoad) {
                                Ext
                                        .defer(
                                                this.load,
                                                10,
                                                this,
                                                [ typeof this.autoLoad == "object" ? this.autoLoad
                                                        : undefined ])
                            }
                        }
                    },
                    getGroups : function() {
                        var d = this.data.items, f = d.length, a = [], c = {}, b, g, h, e;
                        for (e = 0; e < f; e++) {
                            b = d[e];
                            g = this.getGroupString(b);
                            h = c[g];
                            if (h == undefined) {
                                h = {
                                    name : g,
                                    children : []
                                };
                                a.push(h);
                                c[g] = h
                            }
                            h.children.push(b)
                        }
                        return a
                    },
                    getGroupString : function(a) {
                        return a.get(this.groupField)
                    },
                    first : function() {
                        return this.data.first()
                    },
                    last : function() {
                        return this.data.last()
                    },
                    insert : function(d, c) {
                        var e, b, a;
                        c = [].concat(c);
                        for (e = 0, a = c.length; e < a; e++) {
                            b = this.createModel(c[e]);
                            b.set(this.modelDefaults);
                            this.data.insert(d + e, b);
                            b.join(this)
                        }
                        if (this.snapshot) {
                            this.snapshot.addAll(c)
                        }
                        this.fireEvent("add", this, c, d);
                        this.fireEvent("datachanged", this)
                    },
                    add : function(b) {
                        if (!Ext.isArray(b)) {
                            b = Array.prototype.slice.apply(arguments)
                        }
                        var d = b.length, a, c;
                        for (c = 0; c < d; c++) {
                            a = this.createModel(b[c]);
                            if (a.phantom == false) {
                                a.needsAdd = true
                            }
                            b[c] = a
                        }
                        this.insert(this.data.length, b);
                        return b
                    },
                    createModel : function(a) {
                        if (!(a instanceof Ext.data.Model)) {
                            a = Ext.ModelMgr.create(a, this.model)
                        }
                        return a
                    },
                    each : function(b, a) {
                        this.data.each(b, a)
                    },
                    remove : function(b) {
                        if (!Ext.isArray(b)) {
                            b = [ b ]
                        }
                        var e = b.length, d, c, a;
                        for (d = 0; d < e; d++) {
                            a = b[d];
                            c = this.data.indexOf(a);
                            if (c > -1) {
                                this.removed.push(a);
                                if (this.snapshot) {
                                    this.snapshot.remove(a)
                                }
                                a.unjoin(this);
                                this.data.remove(a);
                                this.fireEvent("remove", this, a, c)
                            }
                        }
                        this.fireEvent("datachanged", this)
                    },
                    removeAt : function(b) {
                        var a = this.getAt(b);
                        if (a) {
                            this.remove(a)
                        }
                    },
                    load : function(a) {
                        a = a || {};
                        if (Ext.isFunction(a)) {
                            a = {
                                callback : a
                            }
                        }
                        Ext.applyIf(a, {
                            group : {
                                field : this.groupField,
                                direction : this.groupDir
                            },
                            start : 0,
                            limit : this.pageSize,
                            addRecords : false
                        });
                        return Ext.data.Store.superclass.load.call(this, a)
                    },
                    isLoading : function() {
                        return this.loading
                    },
                    onProxyLoad : function(b) {
                        var a = b.getRecords();
                        this.loadRecords(a, b.addRecords);
                        this.loading = false;
                        this.fireEvent("load", this, a, b.wasSuccessful());
                        this.fireEvent("read", this, a, b.wasSuccessful());
                        var c = b.callback;
                        if (typeof c == "function") {
                            c.call(b.scope || this, a, b, b.wasSuccessful())
                        }
                    },
                    onProxyWrite : function(c) {
                        var g = this.data, f = c.action, b = c.getRecords(), e = b.length, h = c.callback, a, d;
                        if (c.wasSuccessful()) {
                            if (f == "create" || f == "update") {
                                for (d = 0; d < e; d++) {
                                    a = b[d];
                                    a.phantom = false;
                                    a.join(this);
                                    g.replace(a)
                                }
                            } else {
                                if (f == "destroy") {
                                    for (d = 0; d < e; d++) {
                                        a = b[d];
                                        a.unjoin(this);
                                        g.remove(a)
                                    }
                                    this.removed = []
                                }
                            }
                            this.fireEvent("datachanged")
                        }
                        if (typeof h == "function") {
                            h.call(c.scope || this, b, c, c.wasSuccessful())
                        }
                    },
                    getNewRecords : function() {
                        return this.data.filterBy(this.filterNew).items
                    },
                    getUpdatedRecords : function() {
                        return this.data.filterBy(this.filterDirty).items
                    },
                    sort : function(e, d) {
                        if (Ext.isString(e)) {
                            var c = e, b = this.sortToggle, a = Ext.util.Format.toggle;
                            if (d == undefined) {
                                b[c] = a(b[c] || "", "ASC", "DESC");
                                d = b[c]
                            }
                            e = {
                                property : c,
                                direction : d
                            }
                        }
                        if (arguments.length != 0) {
                            this.sorters.clear()
                        }
                        this.sorters.addAll(this.decodeSorters(e));
                        if (this.remoteSort) {
                            this.load()
                        } else {
                            this.data.sort(this.sorters.items);
                            this.fireEvent("datachanged", this)
                        }
                    },
                    filter : function(a, b) {
                        if (Ext.isString(a)) {
                            a = {
                                property : a,
                                value : b
                            }
                        }
                        this.filters.addAll(this.decodeFilters(a));
                        if (this.remoteFilter) {
                            this.load()
                        } else {
                            this.snapshot = this.snapshot || this.data.clone();
                            this.data = this.data.filter(this.filters.items);
                            if (this.sortOnFilter && !this.remoteSort) {
                                this.sort()
                            } else {
                                this.fireEvent("datachanged", this)
                            }
                        }
                    },
                    clearFilter : function(a) {
                        this.filters.clear();
                        if (this.isFiltered()) {
                            this.data = this.snapshot.clone();
                            delete this.snapshot;
                            if (a !== true) {
                                this.fireEvent("datachanged", this)
                            }
                        }
                    },
                    isFiltered : function() {
                        return !!this.snapshot && this.snapshot != this.data
                    },
                    filterBy : function(b, a) {
                        this.snapshot = this.snapshot || this.data.clone();
                        this.data = this.queryBy(b, a || this);
                        this.fireEvent("datachanged", this)
                    },
                    queryBy : function(b, a) {
                        var c = this.snapshot || this.data;
                        return c.filterBy(b, a || this)
                    },
                    loadData : function(f, a) {
                        var c = this.model, e = f.length, d, b;
                        for (d = 0; d < e; d++) {
                            b = f[d];
                            if (!(b instanceof Ext.data.Model)) {
                                f[d] = Ext.ModelMgr.create(b, c)
                            }
                        }
                        this.loadRecords(f, a)
                    },
                    loadRecords : function(a, d) {
                        if (!d) {
                            this.data.clear()
                        }
                        this.data.addAll(a);
                        for ( var b = 0, c = a.length; b < c; b++) {
                            a[b].needsAdd = false;
                            a[b].join(this)
                        }
                        this.suspendEvents();
                        if (this.filterOnLoad && !this.remoteFilter) {
                            this.filter()
                        }
                        if (this.sortOnLoad && !this.remoteSort) {
                            this.sort()
                        }
                        this.resumeEvents();
                        this.fireEvent("datachanged", this, a)
                    },
                    loadPage : function(a) {
                        this.currentPage = a;
                        this.read({
                            page : a,
                            start : (a - 1) * this.pageSize,
                            limit : this.pageSize,
                            addRecords : !this.clearOnPageLoad
                        })
                    },
                    nextPage : function() {
                        this.loadPage(this.currentPage + 1)
                    },
                    previousPage : function() {
                        this.loadPage(this.currentPage - 1)
                    },
                    clearData : function() {
                        this.data.each(function(a) {
                            a.unjoin()
                        });
                        this.data.clear()
                    },
                    find : function(e, d, g, f, a, c) {
                        var b = this.createFilterFn(e, d, f, a, c);
                        return b ? this.data.findIndexBy(b, null, g) : -1
                    },
                    findRecord : function() {
                        var a = this.find.apply(this, arguments);
                        return a != -1 ? this.getAt(a) : null
                    },
                    createFilterFn : function(d, c, e, a, b) {
                        if (Ext.isEmpty(c)) {
                            return false
                        }
                        c = this.data.createValueMatcher(c, e, a, b);
                        return function(f) {
                            return c.test(f.data[d])
                        }
                    },
                    findExact : function(b, a, c) {
                        return this.data.findIndexBy(function(d) {
                            return d.get(b) === a
                        }, this, c)
                    },
                    findBy : function(b, a, c) {
                        return this.data.findIndexBy(b, a, c)
                    },
                    collect : function(f, g, a) {
                        var k = [], h = {}, b, j, e, d, c;
                        if (a === true && this.snapshot) {
                            d = this.snapshot.items
                        } else {
                            d = this.data.items
                        }
                        b = d.length;
                        for (c = 0; c < b; c++) {
                            j = d[c].data[f];
                            e = String(j);
                            if ((g || !Ext.isEmpty(j)) && !h[e]) {
                                h[e] = true;
                                k[k.length] = j
                            }
                        }
                        return k
                    },
                    sum : function(e, f, a) {
                        var b = this.data.items, d = 0, c;
                        f = f || 0;
                        a = (a || a === 0) ? a : b.length - 1;
                        for (c = f; c <= a; c++) {
                            d += (b[c].data[e] || 0)
                        }
                        return d
                    },
                    getCount : function() {
                        return this.data.length || 0
                    },
                    getAt : function(a) {
                        return this.data.getAt(a)
                    },
                    getRange : function(b, a) {
                        return this.data.getRange(b, a)
                    },
                    getById : function(a) {
                        return (this.snapshot || this.data).findBy(function(b) {
                            return b.getId() === a
                        })
                    },
                    indexOf : function(a) {
                        return this.data.indexOf(a)
                    },
                    indexOfId : function(a) {
                        return this.data.indexOfKey(a)
                    },
                    removeAll : function(b) {
                        var a = [];
                        this.each(function(c) {
                            a.push(c)
                        });
                        this.clearData();
                        if (this.snapshot) {
                            this.snapshot.clear()
                        }
                        if (b !== true) {
                            this.fireEvent("clear", this, a)
                        }
                    }
                });
Ext.data.TreeStore = Ext
        .extend(
                Ext.data.AbstractStore,
                {
                    clearOnLoad : true,
                    nodeParam : "node",
                    defaultRootId : "root",
                    constructor : function(c) {
                        c = c || {};
                        var a = c.root || {};
                        a.id = a.id || this.defaultRootId;
                        var b = new Ext.data.RecordNode(a);
                        this.tree = new Ext.data.Tree(b);
                        this.tree.treeStore = this;
                        Ext.data.TreeStore.superclass.constructor.call(this, c);
                        if (c.root) {
                            this.read({
                                node : b,
                                doPreload : true
                            })
                        }
                    },
                    getRootNode : function() {
                        return this.tree.getRootNode()
                    },
                    getNodeById : function(a) {
                        return this.tree.getNodeById(a)
                    },
                    load : function(e) {
                        e = e || {};
                        e.params = e.params || {};
                        var f = e.node || this.tree.getRootNode(), d, c, a = this.proxy.reader, b;
                        if (this.clearOnLoad) {
                            while (f.firstChild) {
                                f.removeChild(f.firstChild)
                            }
                        }
                        if (!e.doPreload) {
                            Ext.applyIf(e, {
                                node : f
                            });
                            c = f.getRecord();
                            e.params[this.nodeParam] = c ? c.getId() : "root";
                            return Ext.data.TreeStore.superclass.load.call(
                                    this, e)
                        } else {
                            b = a.getRoot(f.isRoot ? f.attributes : f
                                    .getRecord().raw);
                            d = a.extractData(b, true);
                            this.fillNode(f, d);
                            return true
                        }
                    },
                    fillNode : function(g, c) {
                        g.loaded = true;
                        var f = c.length, a, e = 0, d, b = g.subStore;
                        for (; e < f; e++) {
                            d = c[e].raw;
                            c[e].data.leaf = d.leaf;
                            a = new Ext.data.RecordNode({
                                id : c[e].getId(),
                                leaf : d.leaf,
                                record : c[e],
                                expanded : d.expanded
                            });
                            g.appendChild(a);
                            if (c[e].doPreload) {
                                this.load({
                                    node : a,
                                    doPreload : true
                                })
                            }
                        }
                        if (b) {
                            if (this.clearOnLoad) {
                                b.removeAll()
                            }
                            b.add.apply(b, c)
                        }
                    },
                    onProxyLoad : function(b) {
                        var a = b.getRecords();
                        this.fillNode(b.node, a);
                        this.fireEvent("read", this, b.node, a, b
                                .wasSuccessful());
                        var c = b.callback;
                        if (typeof c == "function") {
                            c.call(b.scope || this, a, b, b.wasSuccessful())
                        }
                    },
                    getSubStore : function(a) {
                        if (a && a.node) {
                            a = a.node
                        }
                        return a.getSubStore()
                    },
                    removeAll : function() {
                        var a = this.getRootNode();
                        a.destroy()
                    }
                });
Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), {
    register : function() {
        for ( var a = 0, b; (b = arguments[a]); a++) {
            this.add(b)
        }
    },
    unregister : function() {
        for ( var a = 0, b; (b = arguments[a]); a++) {
            this.remove(this.lookup(b))
        }
    },
    lookup : function(e) {
        if (Ext.isArray(e)) {
            var b = [ "field1" ], d = !Ext.isArray(e[0]);
            if (!d) {
                for ( var c = 2, a = e[0].length; c <= a; ++c) {
                    b.push("field" + c)
                }
            }
            return new Ext.data.ArrayStore({
                data : e,
                fields : b,
                expandData : d,
                autoDestroy : true,
                autoCreated : true
            })
        }
        return Ext.isObject(e) ? (e.events ? e : Ext.create(e, "store")) : this
                .get(e)
    },
    getKey : function(a) {
        return a.storeId
    }
});
Ext.regStore = function(c, b) {
    var a;
    if (Ext.isObject(c)) {
        b = c
    } else {
        b.storeId = c
    }
    if (b instanceof Ext.data.Store) {
        a = b
    } else {
        a = new Ext.data.Store(b)
    }
    return Ext.StoreMgr.register(a)
};
Ext.getStore = function(a) {
    return Ext.StoreMgr.lookup(a)
};
Ext.data.WriterMgr = new Ext.AbstractManager({});
Ext.data.Tree = Ext.extend(Ext.util.Observable, {
    constructor : function(a) {
        this.nodeHash = {};
        this.root = null;
        if (a) {
            this.setRootNode(a)
        }
        this.addEvents("append", "remove", "move", "insert", "beforeappend",
                "beforeremove", "beforemove", "beforeinsert");
        Ext.data.Tree.superclass.constructor.call(this)
    },
    pathSeparator : "/",
    proxyNodeEvent : function() {
        return this.fireEvent.apply(this, arguments)
    },
    getRootNode : function() {
        return this.root
    },
    setRootNode : function(a) {
        this.root = a;
        a.ownerTree = this;
        a.isRoot = true;
        this.registerNode(a);
        return a
    },
    getNodeById : function(a) {
        return this.nodeHash[a]
    },
    registerNode : function(a) {
        this.nodeHash[a.id] = a
    },
    unregisterNode : function(a) {
        delete this.nodeHash[a.id]
    },
    toString : function() {
        return "[Tree" + (this.id ? " " + this.id : "") + "]"
    }
});
Ext.data.Node = Ext
        .extend(
                Ext.util.Observable,
                {
                    constructor : function(a) {
                        this.attributes = a || {};
                        this.leaf = !!this.attributes.leaf;
                        this.id = this.attributes.id;
                        if (!this.id) {
                            this.id = Ext.id(null, "xnode-");
                            this.attributes.id = this.id
                        }
                        this.childNodes = [];
                        this.parentNode = null;
                        this.firstChild = null;
                        this.lastChild = null;
                        this.previousSibling = null;
                        this.nextSibling = null;
                        this.addEvents({
                            append : true,
                            remove : true,
                            move : true,
                            insert : true,
                            beforeappend : true,
                            beforeremove : true,
                            beforemove : true,
                            beforeinsert : true
                        });
                        this.listeners = this.attributes.listeners;
                        Ext.data.Node.superclass.constructor.call(this)
                    },
                    fireEvent : function(b) {
                        if (Ext.data.Node.superclass.fireEvent.apply(this,
                                arguments) === false) {
                            return false
                        }
                        var a = this.getOwnerTree();
                        if (a) {
                            if (a.proxyNodeEvent.apply(a, arguments) === false) {
                                return false
                            }
                        }
                        return true
                    },
                    isLeaf : function() {
                        return this.leaf === true
                    },
                    setFirstChild : function(a) {
                        this.firstChild = a
                    },
                    setLastChild : function(a) {
                        this.lastChild = a
                    },
                    isLast : function() {
                        return (!this.parentNode ? true
                                : this.parentNode.lastChild == this)
                    },
                    isFirst : function() {
                        return (!this.parentNode ? true
                                : this.parentNode.firstChild == this)
                    },
                    hasChildNodes : function() {
                        return !this.isLeaf() && this.childNodes.length > 0
                    },
                    isExpandable : function() {
                        return this.attributes.expandable
                                || this.hasChildNodes()
                    },
                    appendChild : function(e) {
                        var f = false, d, a;
                        if (Ext.isArray(e)) {
                            f = e
                        } else {
                            if (arguments.length > 1) {
                                f = arguments
                            }
                        }
                        if (f) {
                            a = f.length;
                            for (d = 0; d < a; d++) {
                                this.appendChild(f[d])
                            }
                        } else {
                            if (this.fireEvent("beforeappend", this.ownerTree,
                                    this, e) === false) {
                                return false
                            }
                            var b = this.childNodes.length;
                            var c = e.parentNode;
                            if (c) {
                                if (e.fireEvent("beforemove", e.getOwnerTree(),
                                        e, c, this, b) === false) {
                                    return false
                                }
                                c.removeChild(e)
                            }
                            b = this.childNodes.length;
                            if (b === 0) {
                                this.setFirstChild(e)
                            }
                            this.childNodes.push(e);
                            e.parentNode = this;
                            var g = this.childNodes[b - 1];
                            if (g) {
                                e.previousSibling = g;
                                g.nextSibling = e
                            } else {
                                e.previousSibling = null
                            }
                            e.nextSibling = null;
                            this.setLastChild(e);
                            e.setOwnerTree(this.getOwnerTree());
                            this
                                    .fireEvent("append", this.ownerTree, this,
                                            e, b);
                            if (c) {
                                e.fireEvent("move", this.ownerTree, e, c, this,
                                        b)
                            }
                            return e
                        }
                    },
                    removeChild : function(c, b) {
                        var a = this.indexOf(c);
                        if (a == -1) {
                            return false
                        }
                        if (this.fireEvent("beforeremove", this.ownerTree,
                                this, c) === false) {
                            return false
                        }
                        this.childNodes.splice(a, 1);
                        if (c.previousSibling) {
                            c.previousSibling.nextSibling = c.nextSibling
                        }
                        if (c.nextSibling) {
                            c.nextSibling.previousSibling = c.previousSibling
                        }
                        if (this.firstChild == c) {
                            this.setFirstChild(c.nextSibling)
                        }
                        if (this.lastChild == c) {
                            this.setLastChild(c.previousSibling)
                        }
                        this.fireEvent("remove", this.ownerTree, this, c);
                        if (b) {
                            c.destroy(true)
                        } else {
                            c.clear()
                        }
                        return c
                    },
                    clear : function(a) {
                        this.setOwnerTree(null, a);
                        this.parentNode = this.previousSibling = this.nextSibling = null;
                        if (a) {
                            this.firstChild = this.lastChild = null
                        }
                    },
                    destroy : function(a) {
                        if (a === true) {
                            this.clearListeners();
                            this.clear(true);
                            Ext.each(this.childNodes, function(b) {
                                b.destroy(true)
                            });
                            this.childNodes = null
                        } else {
                            this.remove(true)
                        }
                    },
                    insertBefore : function(d, a) {
                        if (!a) {
                            return this.appendChild(d)
                        }
                        if (d == a) {
                            return false
                        }
                        if (this.fireEvent("beforeinsert", this.ownerTree,
                                this, d, a) === false) {
                            return false
                        }
                        var b = this.indexOf(a), c = d.parentNode, e = b;
                        if (c == this && this.indexOf(d) < b) {
                            e--
                        }
                        if (c) {
                            if (d.fireEvent("beforemove", d.getOwnerTree(), d,
                                    c, this, b, a) === false) {
                                return false
                            }
                            c.removeChild(d)
                        }
                        if (e === 0) {
                            this.setFirstChild(d)
                        }
                        this.childNodes.splice(e, 0, d);
                        d.parentNode = this;
                        var f = this.childNodes[e - 1];
                        if (f) {
                            d.previousSibling = f;
                            f.nextSibling = d
                        } else {
                            d.previousSibling = null
                        }
                        d.nextSibling = a;
                        a.previousSibling = d;
                        d.setOwnerTree(this.getOwnerTree());
                        this.fireEvent("insert", this.ownerTree, this, d, a);
                        if (c) {
                            d.fireEvent("move", this.ownerTree, d, c, this, e,
                                    a)
                        }
                        return d
                    },
                    remove : function(b) {
                        var a = this.parentNode;
                        if (a) {
                            a.removeChild(this, b)
                        }
                        return this
                    },
                    removeAll : function(a) {
                        var c = this.childNodes, b;
                        while ((b = c[0])) {
                            this.removeChild(b, a)
                        }
                        return this
                    },
                    getChildAt : function(a) {
                        return this.childNodes[a]
                    },
                    replaceChild : function(a, c) {
                        var b = c ? c.nextSibling : null;
                        this.removeChild(c);
                        this.insertBefore(a, b);
                        return c
                    },
                    indexOf : function(a) {
                        return this.childNodes.indexOf(a)
                    },
                    getOwnerTree : function() {
                        if (!this.ownerTree) {
                            var a = this;
                            while (a) {
                                if (a.ownerTree) {
                                    this.ownerTree = a.ownerTree;
                                    break
                                }
                                a = a.parentNode
                            }
                        }
                        return this.ownerTree
                    },
                    getDepth : function() {
                        var b = 0, a = this;
                        while (a.parentNode) {
                            ++b;
                            a = a.parentNode
                        }
                        return b
                    },
                    setOwnerTree : function(a, b) {
                        if (a != this.ownerTree) {
                            if (this.ownerTree) {
                                this.ownerTree.unregisterNode(this)
                            }
                            this.ownerTree = a;
                            if (b !== true) {
                                Ext.each(this.childNodes, function(c) {
                                    c.setOwnerTree(a)
                                })
                            }
                            if (a) {
                                a.registerNode(this)
                            }
                        }
                    },
                    setId : function(b) {
                        if (b !== this.id) {
                            var a = this.ownerTree;
                            if (a) {
                                a.unregisterNode(this)
                            }
                            this.id = this.attributes.id = b;
                            if (a) {
                                a.registerNode(this)
                            }
                            this.onIdChange(b)
                        }
                    },
                    onIdChange : Ext.emptyFn,
                    getPath : function(c) {
                        c = c || "id";
                        var e = this.parentNode, a = [ this.attributes[c] ];
                        while (e) {
                            a.unshift(e.attributes[c]);
                            e = e.parentNode
                        }
                        var d = this.getOwnerTree().pathSeparator;
                        return d + a.join(d)
                    },
                    bubble : function(c, b, a) {
                        var d = this;
                        while (d) {
                            if (c.apply(b || d, a || [ d ]) === false) {
                                break
                            }
                            d = d.parentNode
                        }
                    },
                    cascadeBy : function(d, c, a) {
                        if (d.apply(c || this, a || [ this ]) !== false) {
                            var f = this.childNodes, e = f.length, b;
                            for (b = 0; b < e; b++) {
                                f[b].cascadeBy(d, c, a)
                            }
                        }
                    },
                    eachChild : function(d, c, a) {
                        var f = this.childNodes, e = f.length, b;
                        for (b = 0; b < e; b++) {
                            if (d.apply(c || this, a || [ f[b] ]) === false) {
                                break
                            }
                        }
                    },
                    findChild : function(b, c, a) {
                        return this.findChildBy(function() {
                            return this.attributes[b] == c
                        }, null, a)
                    },
                    findChildBy : function(g, f, b) {
                        var e = this.childNodes, a = e.length, d = 0, h, c;
                        for (; d < a; d++) {
                            h = e[d];
                            if (g.call(f || h, h) === true) {
                                return h
                            } else {
                                if (b) {
                                    c = h.findChildBy(g, f, b);
                                    if (c != null) {
                                        return c
                                    }
                                }
                            }
                        }
                        return null
                    },
                    sort : function(e, d) {
                        var c = this.childNodes, a = c.length, b, g;
                        if (a > 0) {
                            var f = d ? function() {
                                return e.apply(d, arguments)
                            } : e;
                            c.sort(f);
                            for (b = 0; b < a; b++) {
                                g = c[b];
                                g.previousSibling = c[b - 1];
                                g.nextSibling = c[b + 1];
                                if (b === 0) {
                                    this.setFirstChild(g)
                                }
                                if (b == a - 1) {
                                    this.setLastChild(g)
                                }
                            }
                        }
                    },
                    contains : function(a) {
                        return a.isAncestor(this)
                    },
                    isAncestor : function(a) {
                        var b = this.parentNode;
                        while (b) {
                            if (b == a) {
                                return true
                            }
                            b = b.parentNode
                        }
                        return false
                    },
                    toString : function() {
                        return "[Node" + (this.id ? " " + this.id : "") + "]"
                    }
                });
Ext.data.RecordNode = Ext.extend(Ext.data.Node, {
    constructor : function(a) {
        a = a || {};
        if (a.record) {
            a.record.node = this
        }
        Ext.data.RecordNode.superclass.constructor.call(this, a)
    },
    getChildRecords : function() {
        var e = this.childNodes, d = e.length, b = 0, a = [], c;
        for (; b < d; b++) {
            c = e[b].attributes.record;
            c.data.leaf = e[b].leaf;
            a.push(c)
        }
        return a
    },
    getRecord : function() {
        return this.attributes.record
    },
    getSubStore : function() {
        if (this.isLeaf()) {
            throw "Attempted to get a substore of a leaf node."
        }
        var b = this.getOwnerTree().treeStore;
        if (!this.subStore) {
            this.subStore = new Ext.data.Store({
                model : b.model
            });
            var a = this.getChildRecords();
            this.subStore.add.apply(this.subStore, a)
        }
        if (!this.loaded) {
            b.load({
                node : this
            })
        }
        return this.subStore
    },
    destroy : function(b) {
        if (this.subStore) {
            this.subStore.destroyStore()
        }
        var a = this.attributes;
        if (a.record) {
            delete a.record.node;
            delete a.record
        }
        return Ext.data.RecordNode.superclass.destroy.call(this, b)
    }
});
Ext.data.Proxy = Ext.extend(Ext.util.Observable,
        {
            batchOrder : "create,update,destroy",
            defaultReaderType : "json",
            defaultWriterType : "json",
            constructor : function(a) {
                a = a || {};
                if (a.model == undefined) {
                    delete a.model
                }
                Ext.data.Proxy.superclass.constructor.call(this, a);
                if (this.model != undefined
                        && !(this.model instanceof Ext.data.Model)) {
                    this.setModel(this.model)
                }
            },
            setModel : function(b, c) {
                this.model = Ext.ModelMgr.getModel(b);
                var a = this.reader, d = this.writer;
                this.setReader(a);
                this.setWriter(d);
                if (c && this.store) {
                    this.store.setModel(this.model)
                }
            },
            getModel : function() {
                return this.model
            },
            setReader : function(a) {
                if (a == undefined || typeof a == "string") {
                    a = {
                        type : a
                    }
                }
                if (a instanceof Ext.data.Reader) {
                    a.setModel(this.model)
                } else {
                    Ext.applyIf(a, {
                        proxy : this,
                        model : this.model,
                        type : this.defaultReaderType
                    });
                    a = Ext.data.ReaderMgr.create(a)
                }
                this.reader = a;
                return this.reader
            },
            getReader : function() {
                return this.reader
            },
            setWriter : function(a) {
                if (a == undefined || typeof a == "string") {
                    a = {
                        type : a
                    }
                }
                if (!(a instanceof Ext.data.Writer)) {
                    Ext.applyIf(a, {
                        model : this.model,
                        type : this.defaultWriterType
                    });
                    a = Ext.data.WriterMgr.create(a)
                }
                this.writer = a;
                return this.writer
            },
            getWriter : function() {
                return this.writer
            },
            create : Ext.emptyFn,
            read : Ext.emptyFn,
            update : Ext.emptyFn,
            destroy : Ext.emptyFn,
            batch : function(b, c) {
                var a = new Ext.data.Batch({
                    proxy : this,
                    listeners : c || {}
                });
                Ext.each(this.batchOrder.split(","), function(d) {
                    if (b[d]) {
                        a.add(new Ext.data.Operation({
                            action : d,
                            records : b[d]
                        }))
                    }
                }, this);
                a.start();
                return a
            }
        });
Ext.data.DataProxy = Ext.data.Proxy;
Ext.data.ProxyMgr.registerType("proxy", Ext.data.Proxy);
Ext.data.ServerProxy = Ext
        .extend(
                Ext.data.Proxy,
                {
                    pageParam : "page",
                    startParam : "start",
                    limitParam : "limit",
                    groupParam : "group",
                    sortParam : "sort",
                    filterParam : "filter",
                    noCache : true,
                    cacheString : "_dc",
                    timeout : 30000,
                    constructor : function(a) {
                        a = a || {};
                        Ext.data.ServerProxy.superclass.constructor.call(this,
                                a);
                        this.extraParams = a.extraParams || {};
                        this.nocache = this.noCache
                    },
                    create : function() {
                        return this.doRequest.apply(this, arguments)
                    },
                    read : function() {
                        return this.doRequest.apply(this, arguments)
                    },
                    update : function() {
                        return this.doRequest.apply(this, arguments)
                    },
                    destroy : function() {
                        return this.doRequest.apply(this, arguments)
                    },
                    buildRequest : function(a) {
                        var c = Ext.applyIf(a.params || {}, this.extraParams
                                || {});
                        c = Ext.applyIf(c, this.getParams(c, a));
                        var b = new Ext.data.Request({
                            params : c,
                            action : a.action,
                            records : a.records,
                            operation : a
                        });
                        b.url = this.buildUrl(b);
                        a.request = b;
                        return b
                    },
                    encodeSorters : function(d) {
                        var b = [], c = d.length, a;
                        for (a = 0; a < c; a++) {
                            b[a] = {
                                property : d[a].property,
                                direction : d[a].direction
                            }
                        }
                        return Ext.encode(b)
                    },
                    encodeFilters : function(d) {
                        var b = [], c = d.length, a;
                        for (a = 0; a < c; a++) {
                            b[a] = {
                                property : d[a].property,
                                value : d[a].value
                            }
                        }
                        return Ext.encode(b)
                    },
                    encodeGroupers : function(a) {
                        return Ext.encode(a)
                    },
                    getParams : function(e, f) {
                        e = e || {};
                        var l = f.group, k = f.sorters, d = f.filters, j = f.page, b = f.start, g = f.limit, n = this.pageParam, i = this.startParam, m = this.limitParam, h = this.groupParam, c = this.sortParam, a = this.filterParam;
                        if (n && j) {
                            e[n] = j
                        }
                        if (i && b) {
                            e[i] = b
                        }
                        if (m && g) {
                            e[m] = g
                        }
                        if (h && l && l.field) {
                            e[h] = this.encodeGroupers(l)
                        }
                        if (c && k && k.length > 0) {
                            e[c] = this.encodeSorters(k)
                        }
                        if (a && d && d.length > 0) {
                            e[a] = this.encodeFilters(d)
                        }
                        return e
                    },
                    buildUrl : function(b) {
                        var a = b.url || this.url;
                        if (!a) {
                            throw new Error(
                                    "You are using a ServerProxy but have not supplied it with a url.")
                        }
                        if (this.noCache) {
                            a = Ext.urlAppend(a, Ext.util.Format.format(
                                    "{0}={1}", this.cacheString, (new Date()
                                            .getTime())))
                        }
                        return a
                    },
                    doRequest : function(a, c, b) {
                        throw new Error(
                                "The doRequest function has not been implemented on your Ext.data.ServerProxy subclass. See src/data/ServerProxy.js for details")
                    },
                    afterRequest : Ext.emptyFn,
                    onDestroy : function() {
                        Ext.destroy(this.reader, this.writer);
                        Ext.data.ServerProxy.superclass.destroy.apply(this,
                                arguments)
                    }
                });
Ext.data.AjaxProxy = Ext
        .extend(
                Ext.data.ServerProxy,
                {
                    actionMethods : {
                        create : "POST",
                        read : "GET",
                        update : "POST",
                        destroy : "POST"
                    },
                    constructor : function() {
                        this.addEvents("exception");
                        Ext.data.AjaxProxy.superclass.constructor.apply(this,
                                arguments)
                    },
                    doRequest : function(a, e, b) {
                        var d = this.getWriter(), c = this
                                .buildRequest(a, e, b);
                        if (a.allowWrite()) {
                            c = d.write(c)
                        }
                        Ext.apply(c, {
                            headers : this.headers,
                            timeout : this.timeout,
                            scope : this,
                            callback : this.createRequestCallback(c, a, e, b),
                            method : this.getMethod(c),
                            disableCaching : false
                        });
                        Ext.Ajax.request(c);
                        return c
                    },
                    getMethod : function(a) {
                        return this.actionMethods[a.action]
                    },
                    createRequestCallback : function(d, a, e, b) {
                        var c = this;
                        return function(o, n, h) {
                            if (n === true) {
                                var l = c.getReader(), p = l.read(h), g = p.records, f = g.length, m = new Ext.util.MixedCollection(
                                        true, function(i) {
                                            return i.getId()
                                        }), k, j;
                                m.addAll(a.records);
                                for (j = 0; j < f; j++) {
                                    k = m.get(g[j].getId());
                                    if (k) {
                                        k.set(k.data)
                                    }
                                }
                                Ext.apply(a, {
                                    response : h,
                                    resultSet : p
                                });
                                a.setCompleted();
                                a.setSuccessful()
                            } else {
                                c.fireEvent("exception", this, h, a);
                                a.setException()
                            }
                            if (typeof e == "function") {
                                e.call(b || c, a)
                            }
                            c.afterRequest(d, true)
                        }
                    }
                });
Ext.data.ProxyMgr.registerType("ajax", Ext.data.AjaxProxy);
Ext.data.HttpProxy = Ext.data.AjaxProxy;
Ext.data.RestProxy = Ext.extend(Ext.data.AjaxProxy, {
    appendId : true,
    actionMethods : {
        create : "POST",
        read : "GET",
        update : "PUT",
        destroy : "DELETE"
    },
    api : {
        create : "create",
        read : "read",
        update : "update",
        destroy : "destroy"
    },
    buildUrl : function(d) {
        var b = d.operation.records || [], a = b[0], e = this.format, c = d.url
                || this.url;
        if (this.appendId && a) {
            if (!c.match(/\/$/)) {
                c += "/"
            }
            c += a.getId()
        }
        if (e) {
            if (!c.match(/\.$/)) {
                c += "."
            }
            c += e
        }
        d.url = c;
        return Ext.data.RestProxy.superclass.buildUrl.apply(this, arguments)
    }
});
Ext.data.ProxyMgr.registerType("rest", Ext.data.RestProxy);
Ext.apply(Ext, {
    getHead : function() {
        var a;
        return function() {
            if (a == undefined) {
                a = Ext.get(document.getElementsByTagName("head")[0])
            }
            return a
        }
    }()
});
Ext.data.ScriptTagProxy = Ext
        .extend(
                Ext.data.ServerProxy,
                {
                    defaultWriterType : "base",
                    callbackParam : "callback",
                    scriptIdPrefix : "stcScript",
                    callbackPrefix : "stcCallback",
                    recordParam : "records",
                    lastRequest : undefined,
                    autoAppendParams : true,
                    constructor : function() {
                        this.addEvents("exception");
                        Ext.data.ScriptTagProxy.superclass.constructor.apply(
                                this, arguments)
                    },
                    doRequest : function(f, j, k) {
                        var i = Ext.util.Format.format, a = ++Ext.data.ScriptTagProxy.TRANS_ID, c = i(
                                "{0}{1}", this.scriptIdPrefix, a), d = i(
                                "{0}{1}", this.callbackPrefix, a);
                        var e = this.getWriter(), g = this.buildRequest(f), b = Ext
                                .urlAppend(g.url, i("{0}={1}",
                                        this.callbackParam, d));
                        if (f.allowWrite()) {
                            g = e.write(g)
                        }
                        Ext.apply(g, {
                            url : b,
                            transId : a,
                            scriptId : c,
                            stCallback : d
                        });
                        g.timeoutId = Ext.defer(this.createTimeoutHandler,
                                this.timeout, this, [ g, f ]);
                        window[d] = this.createRequestCallback(g, f, j, k);
                        var h = document.createElement("script");
                        h.setAttribute("src", b);
                        h.setAttribute("async", true);
                        h.setAttribute("type", "text/javascript");
                        h.setAttribute("id", c);
                        Ext.getHead().appendChild(h);
                        f.setStarted();
                        this.lastRequest = g;
                        return g
                    },
                    createRequestCallback : function(d, a, e, b) {
                        var c = this;
                        return function(h) {
                            var g = c.getReader(), f = g.read(h);
                            Ext.apply(a, {
                                response : h,
                                resultSet : f
                            });
                            a.setCompleted();
                            a.setSuccessful();
                            if (typeof e == "function") {
                                e.call(b || c, a)
                            }
                            c.afterRequest(d, true)
                        }
                    },
                    afterRequest : function() {
                        var a = function(b) {
                            return function() {
                                window[b] = undefined;
                                try {
                                    delete window[b]
                                } catch (c) {
                                }
                            }
                        };
                        return function(c, b) {
                            Ext.get(c.scriptId).remove();
                            clearTimeout(c.timeoutId);
                            var d = c.stCallback;
                            if (b) {
                                a(d)();
                                this.lastRequest.completed = true
                            } else {
                                window[d] = a(d)
                            }
                        }
                    }(),
                    buildUrl : function(f) {
                        var b = Ext.data.ScriptTagProxy.superclass.buildUrl
                                .call(this, f), g = Ext.apply({}, f.params), e = g.filters, d, c;
                        delete g.filters;
                        if (this.autoAppendParams) {
                            b = Ext.urlAppend(b, Ext.urlEncode(g))
                        }
                        if (e && e.length) {
                            for (c = 0; c < e.length; c++) {
                                d = e[c];
                                if (d.value) {
                                    b = Ext.urlAppend(b, d.property + "="
                                            + d.value)
                                }
                            }
                        }
                        var a = f.records;
                        if (Ext.isArray(a) && a.length > 0) {
                            b = Ext.urlAppend(b, Ext.util.Format.format(
                                    "{0}={1}", this.recordParam, this
                                            .encodeRecords(a)))
                        }
                        return b
                    },
                    destroy : function() {
                        this.abort();
                        Ext.data.ScriptTagProxy.superclass.destroy.apply(this,
                                arguments)
                    },
                    isLoading : function() {
                        var a = this.lastRequest;
                        return (a != undefined && !a.completed)
                    },
                    abort : function() {
                        if (this.isLoading()) {
                            this.afterRequest(this.lastRequest)
                        }
                    },
                    encodeRecords : function(a) {
                        var d = "";
                        for ( var b = 0, c = a.length; b < c; b++) {
                            d += Ext.urlEncode(a[b].data)
                        }
                        return d
                    },
                    createTimeoutHandler : function(b, a) {
                        this.afterRequest(b, false);
                        this.fireEvent("exception", this, b, a);
                        if (typeof b.callback == "function") {
                            b.callback.call(b.scope || window, null, b.options,
                                    false)
                        }
                    }
                });
Ext.data.ScriptTagProxy.TRANS_ID = 1000;
Ext.data.ProxyMgr.registerType("scripttag", Ext.data.ScriptTagProxy);
Ext.data.ClientProxy = Ext
        .extend(
                Ext.data.Proxy,
                {
                    clear : function() {
                        throw new Error(
                                "The Ext.data.ClientProxy subclass that you are using has not defined a 'clear' function. See src/data/ClientProxy.js for details.")
                    }
                });
Ext.data.MemoryProxy = Ext.extend(Ext.data.ClientProxy, {
    constructor : function(a) {
        Ext.data.MemoryProxy.superclass.constructor.call(this, a);
        this.setReader(this.reader)
    },
    read : function(c, e, d) {
        var b = this.getReader(), a = b.read(this.data);
        Ext.apply(c, {
            resultSet : a
        });
        c.setCompleted();
        if (typeof e == "function") {
            e.call(d || this, c)
        }
    },
    clear : Ext.emptyFn
});
Ext.data.ProxyMgr.registerType("memory", Ext.data.MemoryProxy);
Ext.data.WebStorageProxy = Ext
        .extend(
                Ext.data.ClientProxy,
                {
                    id : undefined,
                    constructor : function(a) {
                        Ext.data.WebStorageProxy.superclass.constructor.call(
                                this, a);
                        this.cache = {};
                        if (this.getStorageObject() == undefined) {
                            throw "Local Storage is not supported in this browser, please use another type of data proxy"
                        }
                        this.id = this.id
                                || (this.store ? this.store.storeId : undefined);
                        if (this.id == undefined) {
                            throw "No unique id was provided to the local storage proxy. See Ext.data.LocalStorageProxy documentation for details"
                        }
                        this.initialize()
                    },
                    create : function(e, h, j) {
                        var d = e.records, c = d.length, a = this.getIds(), b, g, f;
                        e.setStarted();
                        for (f = 0; f < c; f++) {
                            g = d[f];
                            if (g.phantom) {
                                g.phantom = false;
                                b = this.getNextId()
                            } else {
                                b = g.getId()
                            }
                            this.setRecord(g, b);
                            a.push(b)
                        }
                        this.setIds(a);
                        e.setCompleted();
                        e.setSuccessful();
                        if (typeof h == "function") {
                            h.call(j || this, e)
                        }
                    },
                    read : function(e, h, j) {
                        var d = [], a = this.getIds(), c = a.length, f, b, g;
                        if (e.id) {
                            g = this.getRecord(e.id);
                            if (g) {
                                d.push(g);
                                e.setSuccessful()
                            }
                        } else {
                            for (f = 0; f < c; f++) {
                                d.push(this.getRecord(a[f]))
                            }
                            e.setSuccessful()
                        }
                        e.setCompleted();
                        e.resultSet = new Ext.data.ResultSet({
                            records : d,
                            total : d.length,
                            loaded : true
                        });
                        if (typeof h == "function") {
                            h.call(j || this, e)
                        }
                    },
                    update : function(e, h, j) {
                        var d = e.records, c = d.length, a = this.getIds(), g, b, f;
                        e.setStarted();
                        for (f = 0; f < c; f++) {
                            g = d[f];
                            this.setRecord(g);
                            b = g.getId();
                            if (b !== undefined && a.indexOf(b) == -1) {
                                a.push(b)
                            }
                        }
                        this.setIds(a);
                        e.setCompleted();
                        e.setSuccessful();
                        if (typeof h == "function") {
                            h.call(j || this, e)
                        }
                    },
                    destroy : function(b, h, e) {
                        var a = b.records, f = a.length, d = this.getIds(), g = []
                                .concat(d), c;
                        for (c = 0; c < f; c++) {
                            g.remove(a[c].getId());
                            this.removeRecord(a[c], false)
                        }
                        this.setIds(g);
                        if (typeof h == "function") {
                            h.call(e || this, b)
                        }
                    },
                    getRecord : function(c) {
                        if (this.cache[c] == undefined) {
                            var a = Ext.decode(this.getStorageObject().getItem(
                                    this.getRecordKey(c))), f = {}, e = this.model, j = e.prototype.fields.items, d = j.length, g, k, b, h;
                            for (g = 0; g < d; g++) {
                                k = j[g];
                                b = k.name;
                                if (typeof k.decode == "function") {
                                    f[b] = k.decode(a[b])
                                } else {
                                    f[b] = a[b]
                                }
                            }
                            h = new e(f, c);
                            h.phantom = false;
                            this.cache[c] = h
                        }
                        return this.cache[c]
                    },
                    setRecord : function(j, c) {
                        if (c) {
                            j.setId(c)
                        } else {
                            c = j.getId()
                        }
                        var a = j.data, f = {}, h = this.model, k = h.prototype.fields.items, d = k.length, g, l, b;
                        for (g = 0; g < d; g++) {
                            l = k[g];
                            b = l.name;
                            if (typeof l.encode == "function") {
                                f[b] = l.encode(a[b], j)
                            } else {
                                f[b] = a[b]
                            }
                        }
                        var e = this.getStorageObject(), m = this
                                .getRecordKey(c);
                        this.cache[c] = j;
                        e.removeItem(m);
                        e.setItem(m, Ext.encode(f))
                    },
                    removeRecord : function(c, b) {
                        if (c instanceof Ext.data.Model) {
                            c = c.getId()
                        }
                        if (b !== false) {
                            var a = this.getIds();
                            a.remove(c);
                            this.setIds(a)
                        }
                        this.getStorageObject()
                                .removeItem(this.getRecordKey(c))
                    },
                    getRecordKey : function(a) {
                        if (a instanceof Ext.data.Model) {
                            a = a.getId()
                        }
                        return Ext.util.Format.format("{0}-{1}", this.id, a)
                    },
                    getRecordCounterKey : function() {
                        return Ext.util.Format.format("{0}-counter", this.id)
                    },
                    getIds : function() {
                        var b = (this.getStorageObject().getItem(this.id) || "")
                                .split(","), c = b.length, a;
                        if (c == 1 && b[0] == "") {
                            b = []
                        } else {
                            for (a = 0; a < c; a++) {
                                b[a] = parseInt(b[a], 10)
                            }
                        }
                        return b
                    },
                    setIds : function(a) {
                        var b = this.getStorageObject(), c = a.join(",");
                        b.removeItem(this.id);
                        if (!Ext.isEmpty(c)) {
                            b.setItem(this.id, c)
                        }
                    },
                    getNextId : function() {
                        var d = this.getStorageObject(), a = this
                                .getRecordCounterKey(), c = d[a], b, e;
                        if (c == undefined) {
                            b = this.getIds();
                            c = b[b.length - 1] || 0
                        }
                        e = parseInt(c, 10) + 1;
                        d.setItem(a, e);
                        return e
                    },
                    initialize : function() {
                        var a = this.getStorageObject();
                        a.setItem(this.id, a.getItem(this.id) || "")
                    },
                    clear : function() {
                        var d = this.getStorageObject(), c = this.getIds(), a = c.length, b;
                        for (b = 0; b < a; b++) {
                            this.removeRecord(c[b])
                        }
                        d.removeItem(this.getRecordCounterKey());
                        d.removeItem(this.id)
                    },
                    getStorageObject : function() {
                        throw new Error(
                                "The getStorageObject function has not been defined in your Ext.data.WebStorageProxy subclass")
                    }
                });
Ext.data.LocalStorageProxy = Ext.extend(Ext.data.WebStorageProxy, {
    getStorageObject : function() {
        return window.localStorage
    }
});
Ext.data.ProxyMgr.registerType("localstorage", Ext.data.LocalStorageProxy);
Ext.data.SessionStorageProxy = Ext.extend(Ext.data.WebStorageProxy, {
    getStorageObject : function() {
        return window.sessionStorage
    }
});
Ext.data.ProxyMgr.registerType("sessionstorage", Ext.data.SessionStorageProxy);
Ext.data.Reader = Ext
        .extend(
                Object,
                {
                    idProperty : "id",
                    totalProperty : "total",
                    successProperty : "success",
                    root : "",
                    implicitIncludes : true,
                    nullResultSet : new Ext.data.ResultSet({
                        total : 0,
                        count : 0,
                        records : [],
                        success : true
                    }),
                    constructor : function(a) {
                        Ext.apply(this, a || {});
                        this.model = Ext.ModelMgr.getModel(a.model);
                        if (this.model) {
                            this.buildExtractors()
                        }
                    },
                    setModel : function(a, b) {
                        this.model = Ext.ModelMgr.getModel(a);
                        this.buildExtractors(true);
                        if (b && this.proxy) {
                            this.proxy.setModel(this.model, true)
                        }
                    },
                    read : function(a) {
                        var b = a;
                        if (a && a.responseText) {
                            b = this.getResponseData(a)
                        }
                        if (b) {
                            return this.readRecords(b)
                        } else {
                            return this.nullResultSet
                        }
                    },
                    readRecords : function(f) {
                        this.rawData = f;
                        f = this.getData(f);
                        var a = this.getRoot(f), d = a.length, g = true, e, b, c;
                        if (this.totalProperty) {
                            e = parseInt(this.getTotal(f), 10);
                            if (!isNaN(e)) {
                                d = e
                            }
                        }
                        if (this.successProperty) {
                            e = this.getSuccess(f);
                            if (e === false || e === "false") {
                                g = false
                            }
                        }
                        b = this.extractData(a, true);
                        c = b.length;
                        return new Ext.data.ResultSet({
                            total : d || c,
                            count : c,
                            records : b,
                            success : g
                        })
                    },
                    extractData : function(j, a) {
                        var k = [], f = [], d = this.model, c = j.length, l = this.idProperty, e, b, h, g;
                        for (g = 0; g < c; g++) {
                            e = j[g];
                            k = this.extractValues(e);
                            b = this.getId(e);
                            if (a === true) {
                                h = new d(k, b);
                                h.raw = e;
                                f.push(h);
                                if (this.implicitIncludes) {
                                    this.readAssociated(h, e)
                                }
                            } else {
                                k[l] = b;
                                f.push(k)
                            }
                        }
                        return f
                    },
                    readAssociated : function(h, g) {
                        var e = h.associations.items, a = e.length, d, m, n, c, b, k, j, l, f;
                        for (f = 0; f < a; f++) {
                            d = e[f];
                            m = d.name;
                            c = this.getAssociatedDataRoot(g, d.associationKey
                                    || m);
                            n = d.associatedModel;
                            if (c) {
                                k = n.proxy;
                                if (k) {
                                    j = k.getReader()
                                } else {
                                    j = new this.constructor({
                                        model : d.associatedName
                                    })
                                }
                                if (d.type == "hasMany") {
                                    l = h[m]();
                                    l.add.apply(l, j.read(c).records);
                                    b = n.prototype.associations
                                            .findBy(function(i) {
                                                return i.type == "belongsTo"
                                                        && i.associatedName == h.constructor.modelName
                                            });
                                    if (b) {
                                        l.data.each(function(i) {
                                            i[b.instanceName] = h
                                        })
                                    }
                                } else {
                                    if (d.type == "belongsTo") {
                                        h[d.instanceName] = j.read([ c ]).records[0]
                                    }
                                }
                            }
                        }
                    },
                    getAssociatedDataRoot : function(b, a) {
                        return b[a]
                    },
                    extractValues : function(f) {
                        var a = this.model.prototype.fields.items, d = a.length, b = {}, g, e, c;
                        for (c = 0; c < d; c++) {
                            g = a[c];
                            e = this.extractorFunctions[c](f) || g.defaultValue;
                            b[g.name] = e
                        }
                        return b
                    },
                    getData : function(a) {
                        return a
                    },
                    getRoot : function(a) {
                        return a
                    },
                    getResponseData : function(a) {
                        throw new Error(
                                "getResponseData must be implemented in the Ext.data.Reader subclass")
                    },
                    onMetaChange : function(c) {
                        var a = c.fields, b;
                        Ext.apply(this, c);
                        if (a) {
                            b = Ext.regModel("JsonReader-Model" + Ext.id(), {
                                fields : a
                            });
                            this.setModel(b, true)
                        } else {
                            this.buildExtractors(true)
                        }
                    },
                    buildExtractors : function(d) {
                        if (d === true) {
                            delete this.extractorFunctions
                        }
                        if (this.extractorFunctions) {
                            return
                        }
                        var f = this.id || this.idProperty, c = this.totalProperty, b = this.successProperty, e = this.messageProperty;
                        if (c) {
                            this.getTotal = this.createAccessor(c)
                        }
                        if (b) {
                            this.getSuccess = this.createAccessor(b)
                        }
                        if (e) {
                            this.getMessage = this.createAccessor(e)
                        }
                        if (f) {
                            var a = this.createAccessor(f);
                            this.getId = function(g) {
                                var h = a(g);
                                return (h == undefined || h == "") ? null : h
                            }
                        } else {
                            this.getId = function() {
                                return null
                            }
                        }
                        this.buildFieldExtractors()
                    },
                    buildFieldExtractors : function() {
                        var a = this.model.prototype.fields.items, c = a.length, b = 0, f = [], e, d;
                        for (; b < c; b++) {
                            e = a[b];
                            d = (e.mapping !== undefined && e.mapping !== null) ? e.mapping
                                    : e.name;
                            f.push(this.createAccessor(d))
                        }
                        this.extractorFunctions = f
                    }
                });
Ext.data.Writer = Ext.extend(Object, {
    constructor : function(a) {
        Ext.apply(this, a)
    },
    write : function(e) {
        var b = e.operation, a = b.records || [], d = a.length, c = 0, f = [];
        for (; c < d; c++) {
            f.push(this.getRecordData(a[c]))
        }
        return this.writeRecords(e, f)
    },
    getRecordData : function(a) {
        return a.data
    }
});
Ext.data.WriterMgr.registerType("base", Ext.data.Writer);
Ext.data.JsonWriter = Ext.extend(Ext.data.Writer, {
    root : "records",
    encode : false,
    writeRecords : function(a, b) {
        if (this.encode === true) {
            b = Ext.encode(b)
        }
        a.jsonData = a.jsonData || {};
        a.jsonData[this.root] = b;
        return a
    }
});
Ext.data.WriterMgr.registerType("json", Ext.data.JsonWriter);
Ext.data.JsonReader = Ext
        .extend(
                Ext.data.Reader,
                {
                    root : "",
                    readRecords : function(a) {
                        if (a.metaData) {
                            this.onMetaChange(a.metaData)
                        }
                        this.jsonData = a;
                        return Ext.data.JsonReader.superclass.readRecords.call(
                                this, a)
                    },
                    getResponseData : function(a) {
                        try {
                            var c = Ext.decode(a.responseText)
                        } catch (b) {
                            throw "Ext.data.JsonReader.getResponseData: Unable to parse JSON returned by Server."
                        }
                        if (!c) {
                            throw "Ext.data.JsonReader.getResponseData: JSON object not found"
                        }
                        return c
                    },
                    buildExtractors : function() {
                        Ext.data.JsonReader.superclass.buildExtractors.apply(
                                this, arguments);
                        if (this.root) {
                            this.getRoot = this.createAccessor(this.root)
                        } else {
                            this.getRoot = function(a) {
                                return a
                            }
                        }
                    },
                    extractData : function(a, c) {
                        var f = this.record, e = [], d, b;
                        if (f) {
                            d = a.length;
                            for (b = 0; b < d; b++) {
                                e[b] = a[b][f]
                            }
                        } else {
                            e = a
                        }
                        return Ext.data.JsonReader.superclass.extractData.call(
                                this, e, c)
                    },
                    createAccessor : function() {
                        var a = /[\[\.]/;
                        return function(c) {
                            if (Ext.isEmpty(c)) {
                                return Ext.emptyFn
                            }
                            if (Ext.isFunction(c)) {
                                return c
                            }
                            var b = String(c).search(a);
                            if (b >= 0) {
                                return new Function("obj", "return obj"
                                        + (b > 0 ? "." : "") + c)
                            }
                            return function(d) {
                                return d[c]
                            }
                        }
                    }()
                });
Ext.data.ReaderMgr.registerType("json", Ext.data.JsonReader);
Ext.data.TreeReader = Ext.extend(Ext.data.JsonReader,
        {
            extractData : function(b, e) {
                var c = Ext.data.TreeReader.superclass.extractData.call(this,
                        b, e), f = c.length, d = 0, a;
                if (e) {
                    for (; d < f; d++) {
                        a = c[d];
                        a.doPreload = !!this.getRoot(a.raw)
                    }
                }
                return c
            }
        });
Ext.data.ReaderMgr.registerType("tree", Ext.data.TreeReader);
Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
    buildExtractors : function() {
        Ext.data.ArrayReader.superclass.buildExtractors.apply(this, arguments);
        var a = this.model.prototype.fields.items, c = a.length, d = [], b;
        for (b = 0; b < c; b++) {
            d.push(function(e) {
                return function(f) {
                    return f[e]
                }
            }(a[b].mapping || b))
        }
        this.extractorFunctions = d
    }
});
Ext.data.ReaderMgr.registerType("array", Ext.data.ArrayReader);
Ext.data.ArrayStore = Ext.extend(Ext.data.Store, {
    constructor : function(a) {
        a = a || {};
        Ext.applyIf(a, {
            proxy : {
                type : "memory",
                reader : "array"
            }
        });
        Ext.data.ArrayStore.superclass.constructor.call(this, a)
    },
    loadData : function(e, a) {
        if (this.expandData === true) {
            var d = [], b = 0, c = e.length;
            for (; b < c; b++) {
                d[d.length] = [ e[b] ]
            }
            e = d
        }
        Ext.data.ArrayStore.superclass.loadData.call(this, e, a)
    }
});
Ext.reg("arraystore", Ext.data.ArrayStore);
Ext.data.SimpleStore = Ext.data.ArrayStore;
Ext.reg("simplestore", Ext.data.SimpleStore);
Ext.data.JsonStore = Ext.extend(Ext.data.Store, {
    constructor : function(a) {
        a = a || {};
        Ext.applyIf(a, {
            proxy : {
                type : "ajax",
                reader : "json",
                writer : "json"
            }
        });
        Ext.data.JsonStore.superclass.constructor.call(this, a)
    }
});
Ext.reg("jsonstore", Ext.data.JsonStore);
Ext.data.JsonPStore = Ext.extend(Ext.data.Store, {
    constructor : function(a) {
        Ext.data.JsonPStore.superclass.constructor.call(this, Ext.apply(a, {
            reader : new Ext.data.JsonReader(a),
            proxy : new Ext.data.ScriptTagProxy(a)
        }))
    }
});
Ext.reg("jsonpstore", Ext.data.JsonPStore);
Ext.data.XmlWriter = Ext.extend(Ext.data.Writer, {
    documentRoot : "xmlData",
    header : "",
    record : "record",
    writeRecords : function(b, c) {
        var a = this.buildTpl(b, c);
        b.xmlData = a.apply(c);
        return b
    },
    buildTpl : function(e, f) {
        if (this.tpl) {
            return this.tpl
        }
        var c = [], b = this.documentRoot, a = this.record, g, d;
        if (this.header) {
            c.push(this.header)
        }
        c.push("<", b, ">");
        if (f.length > 0) {
            c.push('<tpl for="."><', a, ">");
            g = f[0];
            for (d in g) {
                if (g.hasOwnProperty(d)) {
                    c.push("<", d, ">{", d, "}</", d, ">")
                }
            }
            c.push("</", a, "></tpl>")
        }
        c.push("</", b, ">");
        this.tpl = new Ext.XTemplate(c.join(""));
        return this.tpl
    }
});
Ext.data.WriterMgr.registerType("xml", Ext.data.XmlWriter);
Ext.data.XmlReader = Ext.extend(Ext.data.Reader, {
    createAccessor : function() {
        var a = function(d, c, b) {
            var e = Ext.DomQuery.selectNode(d, c), f;
            if (e && e.firstChild) {
                f = e.firstChild.nodeValue
            }
            return Ext.isEmpty(f) ? b : f
        };
        return function(b) {
            var c;
            if (b == this.totalProperty) {
                c = function(e, d) {
                    var f = a(b, e, d);
                    return parseFloat(f)
                }
            } else {
                if (b == this.successProperty) {
                    c = function(e, d) {
                        var f = a(b, e, true);
                        return (f !== false && f !== "false")
                    }
                } else {
                    c = function(e, d) {
                        return a(b, e, d)
                    }
                }
            }
            return c
        }
    }(),
    getResponseData : function(a) {
        var b = a.responseXML;
        if (!b) {
            throw {
                message : "Ext.data.XmlReader.read: XML data not found"
            }
        }
        return b
    },
    getData : function(a) {
        return a.documentElement || a
    },
    getRoot : function(b) {
        var c = b.nodeName, a = this.root;
        if (!a || (c && c == a)) {
            return b
        } else {
            return Ext.DomQuery.selectNode(a, b)
        }
    },
    constructor : function(a) {
        a = a || {};
        Ext.applyIf(a, {
            idProperty : a.idPath || a.id,
            successProperty : a.success
        });
        Ext.data.XmlReader.superclass.constructor.call(this, a)
    },
    extractData : function(a, b) {
        var c = this.record;
        if (c != a.nodeName) {
            a = Ext.DomQuery.select(c, a)
        } else {
            a = [ a ]
        }
        return Ext.data.XmlReader.superclass.extractData.call(this, a, b)
    },
    getAssociatedDataRoot : function(b, a) {
        return Ext.DomQuery.select(a, b)[0]
    },
    readRecords : function(a) {
        if (Ext.isArray(a)) {
            a = a[0]
        }
        this.xmlData = a;
        return Ext.data.XmlReader.superclass.readRecords.call(this, a)
    }
});
Ext.data.ReaderMgr.registerType("xml", Ext.data.XmlReader);
Ext.data.XmlStore = Ext.extend(Ext.data.Store, {
    constructor : function(a) {
        a = a || {};
        a = a || {};
        Ext.applyIf(a, {
            proxy : {
                type : "ajax",
                reader : "xml",
                writer : "xml"
            }
        });
        Ext.data.XmlStore.superclass.constructor.call(this, a)
    }
});
Ext.reg("xmlstore", Ext.data.XmlStore);
Ext.History = new Ext.util.Observable({
    constructor : function() {
        Ext.History.superclass.constructor.call(this, config);
        this.addEvents("change")
    },
    init : function() {
        var a = this;
        a.setToken(window.location.hash);
        if (Ext.supports.History) {
            window.addEventListener("hashchange", this.onChange)
        } else {
            setInterval(function() {
                var c = a.cleanToken(window.location.hash), b = a.getToken();
                if (c != b) {
                    a.onChange()
                }
            }, 50)
        }
    },
    onChange : function() {
        var b = Ext.History, a = b.cleanToken(window.location.hash);
        if (b.token != a) {
            b.fireEvent("change", a)
        }
        b.setToken(a)
    },
    setToken : function(a) {
        return this.token = this.cleanToken(a)
    },
    cleanToken : function(a) {
        return a[0] == "#" ? a.substr(1) : a
    },
    getToken : function() {
        return this.token
    },
    add : function(a) {
        window.location.hash = this.setToken(a);
        if (!Ext.supports.History) {
            this.onChange()
        }
    }
});
Ext.ControllerManager = new Ext.AbstractManager({
    register : function(c, b) {
        b.id = c;
        Ext.applyIf(b, {
            application : Ext.ApplicationManager.currentApplication
        });
        var a = new Ext.Controller(b);
        if (a.init) {
            a.init()
        }
        this.all.add(a);
        return a
    }
});
Ext.regController = function() {
    return Ext.ControllerManager.register.apply(Ext.ControllerManager,
            arguments)
};
Ext.Controller = Ext
        .extend(
                Ext.util.Observable,
                {
                    constructor : function(a) {
                        this.addEvents("instance-created",
                                "instance-creation-failed", "instance-updated",
                                "instance-update-failed", "instance-destroyed",
                                "instance-destruction-failed");
                        Ext.Controller.superclass.constructor.call(this, a);
                        Ext.apply(this, a || {});
                        if (typeof this.model == "string") {
                            this.model = Ext.ModelMgr.getModel(this.model)
                        }
                    },
                    index : function() {
                        this.render("index", {
                            listeners : {
                                scope : this,
                                edit : this.edit,
                                build : this.build,
                                create : this.onCreateInstance,
                                destroy : this.onDestroyInstance
                            }
                        })
                    },
                    edit : function(a) {
                        var b = this.render("edit", {
                            listeners : this.getEditListeners()
                        });
                        b.loadModel(a)
                    },
                    build : function() {
                        this.render("build", {
                            listeners : this.getBuildListeners()
                        })
                    },
                    create : function(f, c) {
                        c = c || {};
                        var b = this.getModel(), a = new b(f), e = c.success, g = c.failure, d = c.scope
                                || this;
                        a.save({
                            scope : this,
                            success : function(h) {
                                if (typeof e == "function") {
                                    e.call(d, h)
                                }
                                this.fireEvent("instance-created", h)
                            },
                            failure : function(h, i) {
                                if (typeof g == "function") {
                                    g.call(d, h, i)
                                }
                                this
                                        .fireEvent("instance-creation-failed",
                                                h, i)
                            }
                        })
                    },
                    update : function(a, e, b) {
                        b = b || {};
                        var d = b.success, f = b.failure, c = b.scope || this;
                        if (Ext.isObject(e)) {
                            a.set(e)
                        }
                        a.save({
                            scope : this,
                            success : function(g) {
                                if (typeof d == "function") {
                                    d.call(c, g)
                                }
                                this.fireEvent("instance-updated", g)
                            },
                            failure : function(g, h) {
                                if (typeof f == "function") {
                                    f.call(c, g, h)
                                }
                                this.fireEvent("instance-update-failed", g, h)
                            }
                        })
                    },
                    destroy : function(a, b) {
                        b = b || {};
                        var d = b.success, e = b.failure, c = b.scope || this;
                        a.destroy({
                            scope : this,
                            success : function(f) {
                                if (typeof d == "function") {
                                    d.call(c, f)
                                }
                                this.fireEvent("instance-destroyed", f)
                            },
                            failure : function(f, g) {
                                if (typeof e == "function") {
                                    e.call(c, f, g)
                                }
                                this.fireEvent("instance-destruction-failed",
                                        f, g)
                            }
                        })
                    },
                    getBuildListeners : function() {
                        return {
                            scope : this,
                            save : this.onCreateInstance,
                            cancel : this.onCancelBuild
                        }
                    },
                    getEditListeners : function() {
                        return {
                            scope : this,
                            save : this.onUpdateInstance,
                            cancel : this.onCancelEdit
                        }
                    },
                    onCancelEdit : function(a) {
                        return this.closeView(a)
                    },
                    onCancelBuild : function(a) {
                        return this.closeView(a)
                    },
                    onCreateInstance : function(a) {
                        this.create(a.getValues(), {
                            scope : this,
                            success : function(b) {
                                this.closeView(a)
                            },
                            failure : function(b, c) {
                                console.log("fail")
                            }
                        })
                    },
                    onUpdateInstance : function(a) {
                        this.update(a.getRecord(), a.getValues(), {
                            scope : this,
                            success : function(b) {
                                this.closeView(a)
                            },
                            failure : function(b, c) {
                            }
                        })
                    },
                    onDestroyInstance : function(a, b) {
                        this.destroy(a, {
                            scope : this,
                            success : function(c) {
                            },
                            failure : function(c, d) {
                            }
                        })
                    },
                    setRenderTarget : function(a) {
                        Ext.Controller.renderTarget = a
                    },
                    render : function(c, g) {
                        var f = Ext.Controller, b = this.application, d = b ? b.currentProfile
                                : undefined, e, a;
                        Ext.applyIf(c, {
                            profile : d
                        });
                        a = Ext.ComponentMgr.create(c);
                        if (g !== false) {
                            e = d ? d.getRenderTarget(c, b) : g;
                            if (g == undefined) {
                                g = e || (b ? b.defaultTarget : undefined)
                            }
                            if (typeof g == "string") {
                                g = Ext.getCmp(g)
                            }
                            if (g != undefined && g.add) {
                                if (d) {
                                    d.beforeLayout(a, g, b)
                                }
                                g.add(a);
                                if (g.layout && g.layout.setActiveItem) {
                                    g.layout.setActiveItem(a)
                                }
                                g.doComponentLayout();
                                if (d) {
                                    d.afterLayout(a, g, b)
                                }
                            }
                        }
                        return a
                    },
                    control : function(e, d, i) {
                        if (!e || !e.isView) {
                            throw "Trying to control a view that doesnt exist"
                        }
                        var h = i ? e.refs[i] : e, g, f, a, b, c;
                        if (!h) {
                            throw "No item called " + i + " found inside the "
                                    + e.name + " view."
                        }
                        for (g in d) {
                            f = d[g];
                            if (Ext.isObject(f) && !f.fn) {
                                this.control(e, f, g)
                            } else {
                                if (h.refs) {
                                    for (a in h.refs) {
                                        b = h.refs[a];
                                        if (b.isObservable && b.events[g]) {
                                            b.enableBubble(g)
                                        }
                                    }
                                }
                                if (!f.fn) {
                                    c = {};
                                    c[g] = f;
                                    c.scope = this
                                } else {
                                    c = f;
                                    if (c.scope === undefined) {
                                        c.scope = this
                                    }
                                }
                                h.addListener(c)
                            }
                        }
                        return e
                    },
                    getModel : function() {
                        return Ext.ModelMgr.getModel(this.model)
                    },
                    closeView : function(a) {
                        var b = a.ownerCt;
                        if (b) {
                            b.remove(a);
                            b.doLayout();
                            b.setActiveItem(b.items.last())
                        }
                    }
                });
Ext.util.Dispatcher = Ext
        .extend(
                Ext.util.Observable,
                {
                    constructor : function(a) {
                        this.addEvents("before-dispatch", "dispatch");
                        Ext.util.Dispatcher.superclass.constructor
                                .call(this, a)
                    },
                    dispatch : function(c) {
                        var b = new Ext.Interaction(c), a = b.controller, e = b.action, d = Ext.History;
                        if (this.fireEvent("before-dispatch", b) !== false) {
                            if (d && c.historyUrl) {
                                d.suspendEvents(false);
                                d.add(c.historyUrl);
                                Ext.defer(d.resumeEvents, 100, d)
                            }
                            if (a && e) {
                                a[e].call(a, b);
                                b.dispatched = true
                            }
                            this.fireEvent("dispatch", b)
                        }
                    },
                    redirect : function(b) {
                        if (b instanceof Ext.data.Model) {
                        } else {
                            if (typeof b == "string") {
                                var a = Ext.Router.recognize(b);
                                if (a) {
                                    return this.dispatch(a)
                                }
                            }
                        }
                        return null
                    },
                    createRedirect : function(a) {
                        return function() {
                            Ext.Dispatcher.redirect(a)
                        }
                    }
                });
Ext.Dispatcher = new Ext.util.Dispatcher();
Ext.dispatch = function() {
    return Ext.Dispatcher.dispatch.apply(Ext.Dispatcher, arguments)
};
Ext.redirect = function() {
    return Ext.Dispatcher.redirect.apply(Ext.Dispatcher, arguments)
};
Ext.createRedirect = Ext.Dispatcher.createRedirect;
Ext.util.Router = Ext.extend(Ext.util.Observable, {
    constructor : function(a) {
        a = a || {};
        Ext.apply(this, a, {
            defaults : {
                action : "index"
            }
        });
        this.routes = [];
        Ext.util.Router.superclass.constructor.call(this, a)
    },
    connect : function(b, c) {
        c = Ext.apply({
            url : b
        }, c || {}, this.defaults);
        var a = new Ext.util.Route(c);
        this.routes.push(a);
        return a
    },
    recognize : function(c) {
        var b = this.routes, e = b.length, d, a;
        for (d = 0; d < e; d++) {
            a = b[d].recognize(c);
            if (a != undefined) {
                return a
            }
        }
        return undefined
    },
    draw : function(a) {
        a.call(this, this)
    }
});
Ext.Router = new Ext.util.Router();
Ext.util.Route = Ext.extend(Object, {
    constructor : function(a) {
        Ext.apply(this, a, {
            conditions : {}
        });
        this.paramMatchingRegex = new RegExp(/:([0-9A-Za-z\_]*)/g);
        this.paramsInMatchString = this.url.match(this.paramMatchingRegex)
                || [];
        this.matcherRegex = this.createMatcherRegex(this.url)
    },
    recognize : function(a) {
        if (this.recognizes(a)) {
            var b = this.matchesFor(a);
            return Ext.applyIf(b, {
                controller : this.controller,
                action : this.action,
                historyUrl : a
            })
        }
    },
    recognizes : function(a) {
        return this.matcherRegex.test(a)
    },
    matchesFor : function(b) {
        var f = {}, e = this.paramsInMatchString, a = b
                .match(this.matcherRegex), d = e.length, c;
        a.shift();
        for (c = 0; c < d; c++) {
            f[e[c].replace(":", "")] = a[c]
        }
        return f
    },
    urlFor : function(a) {
    },
    createMatcherRegex : function(a) {
        var e = this.paramsInMatchString, d = e.length, b, c, f;
        for (b = 0; b < d; b++) {
            c = this.conditions[e[b]];
            f = Ext.util.Format.format("({0})", c || "[%a-zA-Z0-9\\_\\s,]+");
            a = a.replace(new RegExp(e[b]), f)
        }
        return new RegExp("^" + a + "$")
    }
});
Ext.Interaction = Ext.extend(Ext.util.Observable, {
    controller : "",
    action : "",
    dispatched : false,
    constructor : function(a) {
        Ext.Interaction.superclass.constructor.apply(this, arguments);
        a = a || {};
        Ext.applyIf(a, {
            scope : this
        });
        Ext.apply(this, a);
        if (typeof this.controller == "string") {
            this.controller = Ext.ControllerManager.get(this.controller)
        }
    }
});
Ext.Application = Ext
        .extend(
                Ext.util.Observable,
                {
                    scope : undefined,
                    useHistory : true,
                    autoUpdateComponentProfiles : true,
                    setProfilesOnLaunch : true,
                    constructor : function(b) {
                        this.addEvents("launch", "beforeprofilechange",
                                "profilechange");
                        Ext.Application.superclass.constructor.call(this, b);
                        this.bindReady();
                        var a = this.name;
                        if (a) {
                            window[a] = this;
                            Ext.ns(a, a + ".views", a + ".stores", a
                                    + ".models", a + ".controllers")
                        }
                        if (Ext.addMetaTags) {
                            Ext.addMetaTags(b)
                        }
                    },
                    bindReady : function() {
                        Ext.onReady(this.onReady, this)
                    },
                    launch : Ext.emptyFn,
                    useLoadMask : false,
                    loadMaskFadeDuration : 1000,
                    loadMaskRemoveDuration : 1050,
                    autoInitViewport : true,
                    dispatch : function(a) {
                        return Ext.dispatch(a)
                    },
                    initLoadMask : function() {
                        var c = this.useLoadMask, a = "loading-mask", b = typeof c == "string" ? c
                                : a;
                        if (c) {
                            if (b == a) {
                                Ext.getBody().createChild({
                                    id : a
                                })
                            }
                            var e = Ext.get("loading-mask"), d = this.loadMaskFadeDuration, f = this.loadMaskRemoveDuration;
                            Ext.defer(function() {
                                e.addCls("fadeout");
                                Ext.defer(function() {
                                    e.remove()
                                }, f)
                            }, d)
                        }
                    },
                    onBeforeLaunch : function() {
                        var d = Ext.History, c = d && this.useHistory, b = this
                                .determineProfile(true);
                        if (c) {
                            this.historyForm = Ext.getBody().createChild({
                                id : "history-form",
                                cls : "x-hide-display",
                                style : "display: none;",
                                tag : "form",
                                action : "#",
                                children : [ {
                                    tag : "div",
                                    children : [ {
                                        tag : "input",
                                        id : d.fieldId,
                                        type : "hidden"
                                    }, {
                                        tag : "iframe",
                                        id : d.iframeId
                                    } ]
                                } ]
                            });
                            d.init();
                            d.on("change", this.onHistoryChange, this);
                            var a = d.getToken();
                            if (this.launch.call(this.scope || this, b) !== false) {
                                Ext.redirect(a || this.defaultUrl || {
                                    controller : "application",
                                    action : "index"
                                })
                            }
                        } else {
                            this.launch.call(this.scope || this, b)
                        }
                        this.launched = true;
                        this.fireEvent("launch", this);
                        if (this.setProfilesOnLaunch) {
                            this.updateComponentProfiles(b)
                        }
                    },
                    onReady : function() {
                        if (this.useLoadMask) {
                            this.initLoadMask()
                        }
                        Ext.EventManager.onOrientationChange(
                                this.determineProfile, this);
                        if (this.autoInitViewport) {
                            Ext.Viewport.init(this.onBeforeLaunch, this)
                        } else {
                            this.onBeforeLaunch()
                        }
                        return this
                    },
                    determineProfile : function(b) {
                        var d = this.currentProfile, a = this.profiles, c;
                        for (c in a) {
                            if (a[c]() === true) {
                                if (c != d
                                        && this.fireEvent(
                                                "beforeprofilechange", c, d) !== false) {
                                    if (this.autoUpdateComponentProfiles) {
                                        this.updateComponentProfiles(c)
                                    }
                                    if (b !== true) {
                                        this.fireEvent("profilechange", c, d)
                                    }
                                }
                                this.currentProfile = c;
                                break
                            }
                        }
                        return this.currentProfile
                    },
                    updateComponentProfiles : function(a) {
                        Ext.ComponentMgr.each(function(c, b) {
                            if (b.setProfile) {
                                b.setProfile(a)
                            }
                        })
                    },
                    getProfile : function() {
                        return this.currentProfile
                    },
                    onHistoryChange : function(a) {
                        return Ext.redirect(a)
                    }
                });
Ext.ApplicationManager = new Ext.AbstractManager({
    register : function(c, b) {
        if (Ext.isObject(c)) {
            b = c
        } else {
            b.name = c
        }
        var a = new Ext.Application(b);
        this.all.add(a);
        this.currentApplication = a;
        return a
    }
});
Ext.regApplication = function() {
    return Ext.ApplicationManager.register.apply(Ext.ApplicationManager,
            arguments)
};
(function() {
    var c = Ext.Element = Ext.extend(Object, {
        defaultUnit : "px",
        constructor : function(d, e) {
            var f = typeof d == "string" ? document.getElementById(d) : d, g;
            if (!f) {
                return null
            }
            g = f.id;
            if (!e && g && Ext.cache[g]) {
                return Ext.cache[g].el
            }
            this.dom = f;
            this.id = g || Ext.id(f);
            return this
        },
        set : function(h, e) {
            var f = this.dom, d, g;
            for (d in h) {
                if (h.hasOwnProperty(d)) {
                    g = h[d];
                    if (d == "style") {
                        this.applyStyles(g)
                    } else {
                        if (d == "cls") {
                            f.className = g
                        } else {
                            if (e !== false) {
                                f.setAttribute(d, g)
                            } else {
                                f[d] = g
                            }
                        }
                    }
                }
            }
            return this
        },
        is : function(d) {
            return Ext.DomQuery.is(this.dom, d)
        },
        getValue : function(d) {
            var e = this.dom.value;
            return d ? parseInt(e, 10) : e
        },
        addListener : function(d, g, f, e) {
            Ext.EventManager.on(this.dom, d, g, f || this, e);
            return this
        },
        removeListener : function(d, f, e) {
            Ext.EventManager.un(this.dom, d, f, e);
            return this
        },
        removeAllListeners : function() {
            Ext.EventManager.removeAll(this.dom);
            return this
        },
        purgeAllListeners : function() {
            Ext.EventManager.purgeElement(this, true);
            return this
        },
        remove : function() {
            var d = this, e = d.dom;
            if (e) {
                delete d.dom;
                Ext.removeNode(e)
            }
        },
        isAncestor : function(e) {
            var d = this.dom;
            e = Ext.getDom(e);
            if (d && e) {
                return d.contains(e)
            }
            return false
        },
        isDescendent : function(d) {
            return Ext.fly(d, "_internal").isAncestor(this)
        },
        contains : function(d) {
            return !d ? false : this.isAncestor(d)
        },
        getAttribute : function(e, f) {
            var g = this.dom;
            return g.getAttributeNS(f, e) || g.getAttribute(f + ":" + e)
                    || g.getAttribute(e) || g[e]
        },
        setHTML : function(d) {
            if (this.dom) {
                this.dom.innerHTML = d
            }
            return this
        },
        getHTML : function() {
            return this.dom ? this.dom.innerHTML : ""
        },
        hide : function() {
            this.setVisible(false);
            return this
        },
        show : function() {
            this.setVisible(true);
            return this
        },
        setVisible : function(h, d) {
            var e = this, g = e.dom, f = this.getVisibilityMode();
            switch (f) {
            case c.VISIBILITY:
                this.removeCls([ "x-hidden-display", "x-hidden-offsets" ]);
                this[h ? "removeCls" : "addCls"]("x-hidden-visibility");
                break;
            case c.DISPLAY:
                this.removeCls([ "x-hidden-visibility", "x-hidden-offsets" ]);
                this[h ? "removeCls" : "addCls"]("x-hidden-display");
                break;
            case c.OFFSETS:
                this.removeCls([ "x-hidden-visibility", "x-hidden-display" ]);
                this[h ? "removeCls" : "addCls"]("x-hidden-offsets");
                break
            }
            return e
        },
        getVisibilityMode : function() {
            var e = this.dom, d = c.data(e, "visibilityMode");
            if (d === undefined) {
                c.data(e, "visibilityMode", d = c.DISPLAY)
            }
            return d
        },
        setVisibilityMode : function(d) {
            c.data(this.dom, "visibilityMode", d);
            return this
        }
    });
    var a = c.prototype;
    c.VISIBILITY = 1;
    c.DISPLAY = 2;
    c.OFFSETS = 3;
    c.addMethods = function(d) {
        Ext.apply(a, d)
    };
    a.on = a.addListener;
    a.un = a.removeListener;
    a.update = a.setHTML;
    c.get = function(d) {
        var g, f, h;
        if (!d) {
            return null
        }
        if (typeof d == "string") {
            if (!(f = document.getElementById(d))) {
                return null
            }
            if (Ext.cache[d] && Ext.cache[d].el) {
                g = Ext.cache[d].el;
                g.dom = f
            } else {
                g = c.addToCache(new c(f))
            }
            return g
        } else {
            if (d.tagName) {
                if (!(h = d.id)) {
                    h = Ext.id(d)
                }
                if (Ext.cache[h] && Ext.cache[h].el) {
                    g = Ext.cache[h].el;
                    g.dom = d
                } else {
                    g = c.addToCache(new c(d))
                }
                return g
            } else {
                if (d instanceof c) {
                    if (d != c.docEl) {
                        d.dom = document.getElementById(d.id) || d.dom
                    }
                    return d
                } else {
                    if (d.isComposite) {
                        return d
                    } else {
                        if (Ext.isArray(d)) {
                            return c.select(d)
                        } else {
                            if (d == document) {
                                if (!c.docEl) {
                                    var e = function() {
                                    };
                                    e.prototype = a;
                                    c.docEl = new e();
                                    c.docEl.dom = document;
                                    c.docEl.id = Ext.id(document)
                                }
                                return c.docEl
                            }
                        }
                    }
                }
            }
        }
        return null
    };
    c.addToCache = function(d, e) {
        e = e || d.id;
        Ext.cache[e] = {
            el : d,
            data : {},
            events : {}
        };
        return d
    };
    c.data = function(e, d, f) {
        e = c.get(e);
        if (!e) {
            return null
        }
        var g = Ext.cache[e.id].data;
        if (arguments.length == 2) {
            return g[d]
        } else {
            return (g[d] = f)
        }
    };
    c.garbageCollect = function() {
        if (!Ext.enableGarbageCollector) {
            clearInterval(c.collectorThreadId)
        } else {
            var f, e, d = Ext.cache;
            for (f in d) {
                if (!d.hasOwnProperty(f)) {
                    continue
                }
                if (d[f].skipGarbageCollection) {
                    continue
                }
                e = d[f].el.dom;
                if (!e || !e.parentNode
                        || (!e.offsetParent && !document.getElementById(f))) {
                    if (Ext.enableListenerCollection) {
                        Ext.EventManager.removeAll(e)
                    }
                    delete d[f]
                }
            }
        }
    };
    c.Flyweight = function(d) {
        this.dom = d
    };
    var b = function() {
    };
    b.prototype = a;
    c.Flyweight.prototype = new b;
    c.Flyweight.prototype.isFlyweight = true;
    c._flyweights = {};
    c.fly = function(f, d) {
        var e = null;
        d = d || "_global";
        f = Ext.getDom(f);
        if (f) {
            (c._flyweights[d] = c._flyweights[d] || new c.Flyweight()).dom = f;
            e = c._flyweights[d]
        }
        return e
    };
    Ext.get = c.get;
    Ext.fly = c.fly
})();
Ext.applyIf(Ext.Element, {
    unitRe : /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i,
    camelRe : /(-[a-z])/gi,
    opacityRe : /alpha\(opacity=(.*)\)/i,
    propertyCache : {},
    defaultUnit : "px",
    borders : {
        l : "border-left-width",
        r : "border-right-width",
        t : "border-top-width",
        b : "border-bottom-width"
    },
    paddings : {
        l : "padding-left",
        r : "padding-right",
        t : "padding-top",
        b : "padding-bottom"
    },
    margins : {
        l : "margin-left",
        r : "margin-right",
        t : "margin-top",
        b : "margin-bottom"
    },
    addUnits : function(b, a) {
        if (b === "" || b == "auto" || b === null || b === undefined) {
            b = b || ""
        } else {
            if (!isNaN(b) || !this.unitRe.test(b)) {
                b = b + (a || this.defaultUnit || "px")
            }
        }
        return b
    },
    parseBox : function(b) {
        if (typeof b != "string") {
            b = b.toString()
        }
        var c = b.split(" "), a = c.length;
        if (a == 1) {
            c[1] = c[2] = c[3] = c[0]
        } else {
            if (a == 2) {
                c[2] = c[0];
                c[3] = c[1]
            } else {
                if (a == 3) {
                    c[3] = c[1]
                }
            }
        }
        return {
            top : parseFloat(c[0]) || 0,
            right : parseFloat(c[1]) || 0,
            bottom : parseFloat(c[2]) || 0,
            left : parseFloat(c[3]) || 0
        }
    },
    unitizeBox : function(c, b) {
        var a = this.addUnits, d = this.parseBox(c);
        return a(d.top, b) + " " + a(d.right, b) + " " + a(d.bottom, b) + " "
                + a(d.left, b)
    },
    camelReplaceFn : function(b, c) {
        return c.charAt(1).toUpperCase()
    },
    normalize : function(a) {
        return this.propertyCache[a]
                || (this.propertyCache[a] = a == "float" ? "cssFloat" : a
                        .replace(this.camelRe, this.camelReplaceFn))
    },
    getDocumentHeight : function() {
        return Math.max(!Ext.isStrict ? document.body.scrollHeight
                : document.documentElement.scrollHeight, this
                .getViewportHeight())
    },
    getDocumentWidth : function() {
        return Math
                .max(!Ext.isStrict ? document.body.scrollWidth
                        : document.documentElement.scrollWidth, this
                        .getViewportWidth())
    },
    getViewportHeight : function() {
        return window.innerHeight
    },
    getViewportWidth : function() {
        return window.innerWidth
    },
    getViewSize : function() {
        return {
            width : window.innerWidth,
            height : window.innerHeight
        }
    },
    getOrientation : function() {
        if (Ext.supports.OrientationChange) {
            return (window.orientation == 0) ? "portrait" : "landscape"
        }
        return (window.innerHeight > window.innerWidth) ? "portrait"
                : "landscape"
    },
    fromPoint : function(a, b) {
        return Ext.get(document.elementFromPoint(a, b))
    }
});
Ext
        .applyIf(
                Ext.Element,
                {
                    getComputedTransformOffset : function(c) {
                        if (c instanceof Ext.Element) {
                            c = c.dom
                        }
                        var a = window.getComputedStyle(c).webkitTransform, b = a != "none" ? new WebKitCSSMatrix(
                                a)
                                : new WebKitCSSMatrix();
                        if (typeof b.m41 != "undefined") {
                            return new Ext.util.Offset(b.m41, b.m42)
                        } else {
                            if (typeof b.d != "undefined") {
                                return new Ext.util.Offset(b.d, b.e)
                            }
                        }
                        return new Ext.util.Offset(0, 0)
                    },
                    cssTransform : function(c, b) {
                        if (c instanceof Ext.Element) {
                            c = c.dom
                        }
                        var a = new WebKitCSSMatrix();
                        Ext.iterate(b, function(e, d) {
                            d = Ext.isArray(d) ? d : [ d ];
                            a = a[e].apply(a, d)
                        });
                        if (Ext.supports.CSS3DTransform) {
                            c.style.webkitTransform = "matrix3d(" + a.m11
                                    + ", " + a.m12 + ", " + a.m13 + ", "
                                    + a.m14 + ", " + a.m21 + ", " + a.m22
                                    + ", " + a.m23 + ", " + a.m24 + ", "
                                    + a.m31 + ", " + a.m32 + ", " + a.m33
                                    + ", " + a.m34 + ", " + a.m41 + ", "
                                    + a.m42 + ", " + a.m43 + ", " + a.m44 + ")"
                        } else {
                            c.style.webkitTransform = a
                        }
                    },
                    cssTranslate : function(a, b) {
                        if (a instanceof Ext.Element) {
                            a = a.dom
                        }
                        if (Ext.supports.CSS3DTransform) {
                            a.style.webkitTransform = "translate3d(" + b.x
                                    + "px, " + b.y + "px, 0px)"
                        } else {
                            a.style.webkitTransform = "translate(" + b.x
                                    + "px, " + b.y + "px)"
                        }
                    }
                });
Ext.Element
        .addMethods({
            getY : function(a) {
                return this.getXY(a)[1]
            },
            getX : function(a) {
                return this.getXY(a)[0]
            },
            getXY : function() {
                var a = window.webkitConvertPointFromNodeToPage(this.dom,
                        new WebKitPoint(0, 0));
                return [ a.x, a.y ]
            },
            getOffsetsTo : function(a) {
                var c = this.getXY(), b = Ext.fly(a, "_internal").getXY();
                return [ c[0] - b[0], c[1] - b[1] ]
            },
            setXY : function(d) {
                var b = this;
                if (arguments.length > 1) {
                    d = [ d, arguments[1] ]
                }
                var c = b.translatePoints(d), a = b.dom.style;
                for (d in c) {
                    if (!c.hasOwnProperty(d)) {
                        continue
                    }
                    if (!isNaN(c[d])) {
                        a[d] = c[d] + "px"
                    }
                }
                return b
            },
            setX : function(a) {
                return this.setXY([ a, this.getY() ])
            },
            setY : function(a) {
                return this.setXY([ this.getX(), a ])
            },
            setLeft : function(a) {
                this.setStyle("left", Ext.Element.addUnits(a));
                return this
            },
            setTop : function(a) {
                this.setStyle("top", Ext.Element.addUnits(a));
                return this
            },
            setTopLeft : function(c, b) {
                var a = Ext.Element.addUnits;
                this.setStyle("top", a(c));
                this.setStyle("left", a(b));
                return this
            },
            setRight : function(a) {
                this.setStyle("right", Ext.Element.addUnits(a));
                return this
            },
            setBottom : function(a) {
                this.setStyle("bottom", Ext.Element.addUnits(a));
                return this
            },
            getLeft : function(a) {
                return parseInt(this.getStyle("left"), 10) || 0
            },
            getRight : function(a) {
                return parseInt(this.getStyle("right"), 10) || 0
            },
            getTop : function(a) {
                return parseInt(this.getStyle("top"), 10) || 0
            },
            getBottom : function(a) {
                return parseInt(this.getStyle("bottom"), 10) || 0
            },
            setBox : function(d, c, b, a) {
                var e;
                if (Ext.isObject(d)) {
                    b = d.width;
                    a = d.height;
                    c = d.top;
                    d = d.left
                }
                if (d !== e) {
                    this.setLeft(d)
                }
                if (c !== e) {
                    this.setTop(c)
                }
                if (b !== e) {
                    this.setWidth(b)
                }
                if (a !== e) {
                    this.setHeight(a)
                }
                return this
            },
            getBox : function(g, j) {
                var h = this, e = h.dom, c = e.offsetWidth, k = e.offsetHeight, n, f, d, a, m, i;
                if (!j) {
                    n = h.getXY()
                } else {
                    if (g) {
                        n = [ 0, 0 ]
                    } else {
                        n = [ parseInt(h.getStyle("left"), 10) || 0,
                                parseInt(h.getStyle("top"), 10) || 0 ]
                    }
                }
                if (!g) {
                    f = {
                        x : n[0],
                        y : n[1],
                        0 : n[0],
                        1 : n[1],
                        width : c,
                        height : k
                    }
                } else {
                    d = h.getBorderWidth.call(h, "l")
                            + h.getPadding.call(h, "l");
                    a = h.getBorderWidth.call(h, "r")
                            + h.getPadding.call(h, "r");
                    m = h.getBorderWidth.call(h, "t")
                            + h.getPadding.call(h, "t");
                    i = h.getBorderWidth.call(h, "b")
                            + h.getPadding.call(h, "b");
                    f = {
                        x : n[0] + d,
                        y : n[1] + m,
                        0 : n[0] + d,
                        1 : n[1] + m,
                        width : c - (d + a),
                        height : k - (m + i)
                    }
                }
                f.left = f.x;
                f.top = f.y;
                f.right = f.x + f.width;
                f.bottom = f.y + f.height;
                return f
            },
            getPageBox : function(e) {
                var g = this, c = g.dom, j = c.offsetWidth, f = c.offsetHeight, m = g
                        .getXY(), k = m[1], a = m[0] + j, i = m[1] + f, d = m[0];
                if (!c) {
                    return new Ext.util.Region()
                }
                if (e) {
                    return new Ext.util.Region(k, a, i, d)
                } else {
                    return {
                        left : d,
                        top : k,
                        width : j,
                        height : f,
                        right : a,
                        bottom : i
                    }
                }
            },
            translatePoints : function(a, g) {
                g = isNaN(a[1]) ? g : a[1];
                a = isNaN(a[0]) ? a : a[0];
                var d = this, e = d.isStyle("position", "relative"), f = d
                        .getXY(), b = parseInt(d.getStyle("left"), 10), c = parseInt(
                        d.getStyle("top"), 10);
                b = !isNaN(b) ? b : (e ? 0 : d.dom.offsetLeft);
                c = !isNaN(c) ? c : (e ? 0 : d.dom.offsetTop);
                return {
                    left : (a - f[0] + b),
                    top : (g - f[1] + c)
                }
            }
        });
(function() {
    Ext.Element.classReCache = {};
    var b = Ext.Element, a = document.defaultView;
    b
            .addMethods({
                marginRightRe : /marginRight/i,
                trimRe : /^\s+|\s+$/g,
                spacesRe : /\s+/,
                addCls : function(g) {
                    var h = this, f, c, e, d = [];
                    if (!Ext.isArray(g)) {
                        if (g && !this.hasCls(g)) {
                            h.dom.className += " " + g
                        }
                    } else {
                        for (f = 0, c = g.length; f < c; f++) {
                            e = g[f];
                            if (e && !h.hasCls(e)) {
                                d.push(e)
                            }
                        }
                        if (d.length) {
                            h.dom.className += " " + d.join(" ")
                        }
                    }
                    return h
                },
                addClass : function() {
                    throw new Error(
                            "Component: addClass has been deprecated. Please use addCls.")
                },
                removeCls : function(h) {
                    var j = this, g, d, c, f, e;
                    if (!Ext.isArray(h)) {
                        h = [ h ]
                    }
                    if (j.dom && j.dom.className) {
                        e = j.dom.className.replace(this.trimRe, "").split(
                                this.spacesRe);
                        for (g = 0, c = h.length; g < c; g++) {
                            f = h[g];
                            if (typeof f == "string") {
                                f = f.replace(this.trimRe, "");
                                d = e.indexOf(f);
                                if (d != -1) {
                                    e.splice(d, 1)
                                }
                            }
                        }
                        j.dom.className = e.join(" ")
                    }
                    return j
                },
                removeClass : function() {
                    throw new Error(
                            "Component: removeClass has been deprecated. Please use removeCls.")
                },
                mask : function(d, f, i) {
                    var g = this, e = g.dom, c = Ext.Element.data(e, "mask"), k, j, h = "";
                    g.addCls("x-masked");
                    if (g.getStyle("position") == "static") {
                        g.addCls("x-masked-relative")
                    }
                    if (c) {
                        c.remove()
                    }
                    if (Ext.isString(f) && !Ext.isEmpty(f)) {
                        h = " " + f
                    } else {
                        if (f) {
                            h = " x-mask-gray"
                        }
                    }
                    k = g.createChild({
                        cls : "x-mask" + ((i !== false) ? "" : " x-mask-gray"),
                        html : d ? ('<div class="' + (f || "x-mask-message")
                                + '">' + d + "</div>") : ""
                    });
                    j = g.getSize();
                    Ext.Element.data(e, "mask", k);
                    if (e === document.body) {
                        j.height = window.innerHeight;
                        if (g.orientationHandler) {
                            Ext.EventManager.unOrientationChange(
                                    g.orientationHandler, g)
                        }
                        g.orientationHandler = function() {
                            j = g.getSize();
                            j.height = window.innerHeight;
                            k.setSize(j)
                        };
                        Ext.EventManager.onOrientationChange(
                                g.orientationHandler, g)
                    }
                    k.setSize(j);
                    if (Ext.is.iPad) {
                        Ext.repaint()
                    }
                },
                unmask : function() {
                    var d = this, e = d.dom, c = Ext.Element.data(e, "mask");
                    if (c) {
                        c.remove();
                        Ext.Element.data(e, "mask", undefined)
                    }
                    d.removeCls([ "x-masked", "x-masked-relative" ]);
                    if (e === document.body) {
                        Ext.EventManager.unOrientationChange(
                                d.orientationHandler, d);
                        delete d.orientationHandler
                    }
                },
                radioCls : function(f) {
                    var g = this.dom.parentNode.childNodes, d;
                    f = Ext.isArray(f) ? f : [ f ];
                    for ( var e = 0, c = g.length; e < c; e++) {
                        d = g[e];
                        if (d && d.nodeType == 1) {
                            Ext.fly(d, "_internal").removeCls(f)
                        }
                    }
                    return this.addCls(f)
                },
                radioClass : function() {
                    throw new Error(
                            "Component: radioClass has been deprecated. Please use radioCls.")
                },
                toggleCls : function(c) {
                    return this.hasCls(c) ? this.removeCls(c) : this.addCls(c)
                },
                toggleClass : function() {
                    throw new Error(
                            "Component: toggleClass has been deprecated. Please use toggleCls.")
                },
                hasCls : function(c) {
                    return c
                            && (" " + this.dom.className + " ").indexOf(" " + c
                                    + " ") != -1
                },
                hasClass : function() {
                    throw new Error(
                            "Element: hasClass has been deprecated. Please use hasCls.");
                    return this.hasCls.apply(this, arguments)
                },
                replaceCls : function(d, c) {
                    return this.removeCls(d).addCls(c)
                },
                replaceClass : function() {
                    throw new Error(
                            "Component: replaceClass has been deprecated. Please use replaceCls.")
                },
                isStyle : function(c, d) {
                    return this.getStyle(c) == d
                },
                getStyle : function(i) {
                    var h = this.dom, d, g, f, c = Ext.is, e = h.style;
                    i = b.normalize(i);
                    f = (a) ? a.getComputedStyle(h, "") : h.currentStyle;
                    d = (f) ? f[i] : null;
                    if (d && !c.correctRightMargin
                            && this.marginRightRe.test(i)
                            && e.position != "absolute" && d != "0px") {
                        g = e.display;
                        e.display = "inline-block";
                        d = a.getComputedStyle(h, null)[i];
                        e.display = g
                    }
                    d || (d = e[i]);
                    if (!c.correctTransparentColor && d == "rgba(0, 0, 0, 0)") {
                        d = "transparent"
                    }
                    return d
                },
                setStyle : function(f, e) {
                    var c, d;
                    if (typeof f == "string") {
                        c = {};
                        c[f] = e;
                        f = c
                    }
                    for (d in f) {
                        if (f.hasOwnProperty(d)) {
                            this.dom.style[b.normalize(d)] = f[d]
                        }
                    }
                    return this
                },
                applyStyles : function(e) {
                    if (e) {
                        var d, c, f = this.dom;
                        if (typeof e == "function") {
                            e = e.call()
                        }
                        if (typeof e == "string") {
                            e = Ext.util.Format.trim(e).split(/\s*(?::|;)\s*/);
                            for (d = 0, c = e.length; d < c;) {
                                f.style[b.normalize(e[d++])] = e[d++]
                            }
                        } else {
                            if (typeof e == "object") {
                                this.setStyle(e)
                            }
                        }
                    }
                },
                getHeight : function(d) {
                    var e = this.dom, c = d ? (e.clientHeight - this
                            .getPadding("tb")) : e.offsetHeight;
                    return c > 0 ? c : 0
                },
                getWidth : function(c) {
                    var e = this.dom, d = c ? (e.clientWidth - this
                            .getPadding("lr")) : e.offsetWidth;
                    return d > 0 ? d : 0
                },
                setWidth : function(c) {
                    var d = this;
                    d.dom.style.width = b.addUnits(c);
                    return d
                },
                setHeight : function(c) {
                    var d = this;
                    d.dom.style.height = b.addUnits(c);
                    return d
                },
                setSize : function(e, c) {
                    var f = this, d = f.dom.style;
                    if (Ext.isObject(e)) {
                        c = e.height;
                        e = e.width
                    }
                    d.width = b.addUnits(e);
                    d.height = b.addUnits(c);
                    return f
                },
                getBorderWidth : function(c) {
                    return this.sumStyles(c, b.borders)
                },
                getPadding : function(c) {
                    return this.sumStyles(c, b.paddings)
                },
                getMargin : function(c) {
                    return this.sumStyles(c, b.margins)
                },
                getViewSize : function() {
                    var c = document, d = this.dom;
                    if (d == c || d == c.body) {
                        return {
                            width : b.getViewportWidth(),
                            height : b.getViewportHeight()
                        }
                    } else {
                        return {
                            width : d.clientWidth,
                            height : d.clientHeight
                        }
                    }
                },
                getSize : function(d) {
                    var c = this.dom;
                    return {
                        width : Math.max(0, d ? (c.clientWidth - this
                                .getPadding("lr")) : c.offsetWidth),
                        height : Math.max(0, d ? (c.clientHeight - this
                                .getPadding("tb")) : c.offsetHeight)
                    }
                },
                repaint : function() {
                    var c = this.dom;
                    this.addCls("x-repaint");
                    c.style.background = "transparent none";
                    setTimeout(function() {
                        c.style.background = null;
                        Ext.get(c).removeCls("x-repaint")
                    }, 1);
                    return this
                },
                getOuterWidth : function() {
                    return this.getWidth() + this.getMargin("lr")
                },
                getOuterHeight : function() {
                    return this.getHeight() + this.getMargin("tb")
                },
                sumStyles : function(h, g) {
                    var j = 0, d = h.match(/\w/g), c = d.length, f, e;
                    for (e = 0; e < c; e++) {
                        f = d[e] && parseFloat(this.getStyle(g[d[e]])) || 0;
                        if (f) {
                            j += Math.abs(f)
                        }
                    }
                    return j
                }
            })
})();
Ext.Element.addMethods({
    findParent : function(h, g, c) {
        var e = this.dom, a = document.body, f = 0, d;
        g = g || 50;
        if (isNaN(g)) {
            d = Ext.getDom(g);
            g = Number.MAX_VALUE
        }
        while (e && e.nodeType == 1 && f < g && e != a && e != d) {
            if (Ext.DomQuery.is(e, h)) {
                return c ? Ext.get(e) : e
            }
            f++;
            e = e.parentNode
        }
        return null
    },
    findParentNode : function(d, c, a) {
        var b = Ext.fly(this.dom.parentNode, "_internal");
        return b ? b.findParent(d, c, a) : null
    },
    up : function(b, a) {
        return this.findParentNode(b, a, true)
    },
    select : function(a, b) {
        return Ext.Element.select(a, this.dom, b)
    },
    query : function(a) {
        return Ext.DomQuery.select(a, this.dom)
    },
    down : function(a, b) {
        var c = Ext.DomQuery.selectNode(a, this.dom);
        return b ? c : Ext.get(c)
    },
    child : function(a, b) {
        var d, c = this, e;
        e = Ext.get(c).id;
        e = e.replace(/[\.:]/g, "\\$0");
        d = Ext.DomQuery.selectNode("#" + e + " > " + a, c.dom);
        return b ? d : Ext.get(d)
    },
    parent : function(a, b) {
        return this.matchNode("parentNode", "parentNode", a, b)
    },
    next : function(a, b) {
        return this.matchNode("nextSibling", "nextSibling", a, b)
    },
    prev : function(a, b) {
        return this.matchNode("previousSibling", "previousSibling", a, b)
    },
    first : function(a, b) {
        return this.matchNode("nextSibling", "firstChild", a, b)
    },
    last : function(a, b) {
        return this.matchNode("previousSibling", "lastChild", a, b)
    },
    matchNode : function(b, e, a, c) {
        if (!this.dom) {
            return null
        }
        var d = this.dom[e];
        while (d) {
            if (d.nodeType == 1 && (!a || Ext.DomQuery.is(d, a))) {
                return !c ? Ext.get(d) : d
            }
            d = d[b]
        }
        return null
    }
});
Ext.Element.addMethods({
    getScrollParent : function() {
        var b = this.dom, a;
        while (b && b != document.body) {
            if (b.id && (a = Ext.ScrollManager.get(b.id))) {
                return a
            }
            b = b.parentNode
        }
        return null
    }
});
Ext.Element.addMethods({
    appendChild : function(a) {
        return Ext.get(a).appendTo(this)
    },
    appendTo : function(a) {
        Ext.getDom(a).appendChild(this.dom);
        return this
    },
    insertBefore : function(a) {
        a = Ext.getDom(a);
        a.parentNode.insertBefore(this.dom, a);
        return this
    },
    insertAfter : function(a) {
        a = Ext.getDom(a);
        a.parentNode.insertBefore(this.dom, a.nextSibling);
        return this
    },
    insertFirst : function(b, a) {
        b = b || {};
        if (b.nodeType || b.dom || typeof b == "string") {
            b = Ext.getDom(b);
            this.dom.insertBefore(b, this.dom.firstChild);
            return !a ? Ext.get(b) : b
        } else {
            return this.createChild(b, this.dom.firstChild, a)
        }
    },
    insertSibling : function(e, c, d) {
        var f = this, b, a = (c || "before").toLowerCase() == "after", g;
        if (Ext.isArray(e)) {
            g = f;
            Ext.each(e, function(h) {
                b = Ext.fly(g, "_internal").insertSibling(h, c, d);
                if (a) {
                    g = b
                }
            });
            return b
        }
        e = e || {};
        if (e.nodeType || e.dom) {
            b = f.dom.parentNode.insertBefore(Ext.getDom(e),
                    a ? f.dom.nextSibling : f.dom);
            if (!d) {
                b = Ext.get(b)
            }
        } else {
            if (a && !f.dom.nextSibling) {
                b = Ext.DomHelper.append(f.dom.parentNode, e, !d)
            } else {
                b = Ext.DomHelper[a ? "insertAfter" : "insertBefore"](f.dom, e,
                        !d)
            }
        }
        return b
    },
    replace : function(a) {
        a = Ext.get(a);
        this.insertBefore(a);
        a.remove();
        return this
    },
    replaceWith : function(a) {
        var b = this;
        if (a.nodeType || a.dom || typeof a == "string") {
            a = Ext.get(a);
            b.dom.parentNode.insertBefore(a, b.dom)
        } else {
            a = Ext.DomHelper.insertBefore(b.dom, a)
        }
        delete Ext.cache[b.id];
        Ext.removeNode(b.dom);
        b.id = Ext.id(b.dom = a);
        Ext.Element.addToCache(b.isFlyweight ? new Ext.Element(b.dom) : b);
        return b
    },
    createChild : function(b, a, c) {
        b = b || {
            tag : "div"
        };
        if (a) {
            return Ext.DomHelper.insertBefore(a, b, c !== true)
        } else {
            return Ext.DomHelper[!this.dom.firstChild ? "overwrite" : "append"]
                    (this.dom, b, c !== true)
        }
    },
    wrap : function(a, b) {
        var c = Ext.DomHelper.insertBefore(this.dom, a || {
            tag : "div"
        }, !b);
        c.dom ? c.dom.appendChild(this.dom) : c.appendChild(this.dom);
        return c
    },
    insertHtml : function(b, c, a) {
        var d = Ext.DomHelper.insertHtml(b, this.dom, c);
        return a ? Ext.get(d) : d
    }
});
Ext.Element
        .addMethods({
            getAnchorXY : function(f, j, m) {
                f = (f || "tl").toLowerCase();
                m = m || {};
                var i = this, a = i.dom == document.body || i.dom == document, b = m.width
                        || a ? window.innerWidth : i.getWidth(), k = m.height
                        || a ? window.innerHeight : i.getHeight(), l, c = Math.round, d = i
                        .getXY(), h = a ? 0 : !j ? d[0] : 0, g = a ? 0
                        : !j ? d[1] : 0, e = {
                    c : [ c(b * 0.5), c(k * 0.5) ],
                    t : [ c(b * 0.5), 0 ],
                    l : [ 0, c(k * 0.5) ],
                    r : [ b, c(k * 0.5) ],
                    b : [ c(b * 0.5), k ],
                    tl : [ 0, 0 ],
                    bl : [ 0, k ],
                    br : [ b, k ],
                    tr : [ b, 0 ]
                };
                l = e[f];
                return [ l[0] + h, l[1] + g ]
            },
            getAlignToXY : function(e, w, h) {
                e = Ext.get(e);
                if (!e || !e.dom) {
                    throw new Error(
                            "Element.alignToXY with an element that doesn't exist")
                }
                h = h || [ 0, 0 ];
                if (!w || w == "?") {
                    w = "tl-bl?"
                } else {
                    if (!(/-/).test(w) && w !== "") {
                        w = "tl-" + w
                    }
                }
                w = w.toLowerCase();
                var u = this, d = w.match(/^([a-z]+)-([a-z]+)(\?)?$/), m = window.innerWidth, t = window.innerHeight, c = "", a = "", z, v, l, k, p, n, f, b, j, i, q, o, g, s;
                if (!d) {
                    throw "Element.alignTo with an invalid alignment " + w
                }
                c = d[1];
                a = d[2];
                s = !!d[3];
                z = u.getAnchorXY(c, true);
                v = e.getAnchorXY(a, false);
                l = v[0] - z[0] + h[0];
                k = v[1] - z[1] + h[1];
                if (s) {
                    q = u.getWidth();
                    o = u.getHeight();
                    g = e.getPageBox();
                    b = c.charAt(0);
                    f = c.charAt(c.length - 1);
                    i = a.charAt(0);
                    j = a.charAt(a.length - 1);
                    n = ((b == "t" && i == "b") || (b == "b" && i == "t"));
                    p = ((f == "r" && j == "l") || (f == "l" && j == "r"));
                    if (l + q > m) {
                        l = p ? g.left - q : m - q
                    }
                    if (l < 0) {
                        l = p ? g.right : 0
                    }
                    if (k + o > t) {
                        k = n ? g.top - o : t - o
                    }
                    if (k < 0) {
                        k = n ? g.bottom : 0
                    }
                }
                return [ l, k ]
            }
        });
Ext.CompositeElement = function(b, a) {
    this.elements = [];
    this.add(b, a);
    this.el = new Ext.Element.Flyweight()
};
Ext.CompositeElement.prototype = {
    isComposite : true,
    getElement : function(a) {
        var b = this.el;
        b.dom = a;
        b.id = a.id;
        return b
    },
    transformElement : function(a) {
        return Ext.getDom(a)
    },
    getCount : function() {
        return this.elements.length
    },
    add : function(d, b) {
        var e = this, f = e.elements;
        if (!d) {
            return this
        }
        if (typeof d == "string") {
            d = Ext.Element.selectorFunction(d, b)
        } else {
            if (d.isComposite) {
                d = d.elements
            } else {
                if (!Ext.isIterable(d)) {
                    d = [ d ]
                }
            }
        }
        for ( var c = 0, a = d.length; c < a; ++c) {
            f.push(e.transformElement(d[c]))
        }
        return e
    },
    invoke : function(f, b) {
        var g = this, d = g.elements, a = d.length, h, c;
        for (c = 0; c < a; c++) {
            h = d[c];
            if (h) {
                Ext.Element.prototype[f].apply(g.getElement(h), b)
            }
        }
        return g
    },
    item : function(b) {
        var d = this, c = d.elements[b], a = null;
        if (c) {
            a = d.getElement(c)
        }
        return a
    },
    addListener : function(b, h, g, f) {
        var d = this.elements, a = d.length, c, j;
        for (c = 0; c < a; c++) {
            j = d[c];
            if (j) {
                Ext.EventManager.on(j, b, h, g || j, f)
            }
        }
        return this
    },
    each : function(f, d) {
        var g = this, c = g.elements, a = c.length, b, h;
        for (b = 0; b < a; b++) {
            h = c[b];
            if (h) {
                h = this.getElement(h);
                if (f.call(d || h, h, g, b)) {
                    break
                }
            }
        }
        return g
    },
    fill : function(a) {
        var b = this;
        b.elements = [];
        b.add(a);
        return b
    },
    filter : function(a) {
        var b = [], d = this, e = d.elements, c = Ext.isFunction(a) ? a
                : function(f) {
                    return f.is(a)
                };
        d.each(function(h, f, g) {
            if (c(h, g) !== false) {
                b[b.length] = d.transformElement(h)
            }
        });
        d.elements = b;
        return d
    },
    first : function() {
        return this.item(0)
    },
    last : function() {
        return this.item(this.getCount() - 1)
    },
    contains : function(a) {
        return this.indexOf(a) != -1
    },
    indexOf : function(a) {
        return this.elements.indexOf(this.transformElement(a))
    },
    clear : function() {
        this.elements = []
    }
};
Ext.CompositeElement.prototype.on = Ext.CompositeElement.prototype.addListener;
(function() {
    var c, b = Ext.Element.prototype, a = Ext.CompositeElement.prototype;
    for (c in b) {
        if (Ext.isFunction(b[c])) {
            (function(d) {
                a[d] = a[d] || function() {
                    return this.invoke(d, arguments)
                }
            }).call(a, c)
        }
    }
})();
if (Ext.DomQuery) {
    Ext.Element.selectorFunction = Ext.DomQuery.select
}
Ext.Element.select = function(a, b, d) {
    var c;
    d = (d === false) ? false : true;
    if (typeof a == "string") {
        c = Ext.Element.selectorFunction(a, b)
    } else {
        if (a.length !== undefined) {
            c = a
        } else {
            throw new Error("Invalid selector")
        }
    }
    return d ? new Ext.CompositeElement(c) : c
};
Ext.select = Ext.Element.select;
Ext.CompositeElementLite = Ext.CompositeElement;
Ext.apply(Ext.CompositeElementLite.prototype, {
    addElements : function(c, a) {
        if (!c) {
            return this
        }
        if (typeof c == "string") {
            c = Ext.Element.selectorFunction(c, a)
        }
        var b = this.elements;
        Ext.each(c, function(d) {
            b.push(Ext.get(d))
        });
        return this
    },
    removeElement : function(d, e) {
        var c = this, a = this.elements, b;
        Ext.each(d, function(f) {
            if ((b = (a[f] || a[f = c.indexOf(f)]))) {
                if (e) {
                    if (b.dom) {
                        b.remove()
                    } else {
                        Ext.removeNode(b)
                    }
                }
                a.splice(f, 1)
            }
        });
        return this
    },
    replaceElement : function(e, c, a) {
        var b = !isNaN(e) ? e : this.indexOf(e), f;
        if (b > -1) {
            c = Ext.getDom(c);
            if (a) {
                f = this.elements[b];
                f.parentNode.insertBefore(c, f);
                Ext.removeNode(f)
            }
            this.elements.splice(b, 1, c)
        }
        return this
    }
});
Ext.DomHelper = {
    emptyTags : /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
    confRe : /tag|children|cn|html$/i,
    endRe : /end/i,
    markup : function(h) {
        var d = "", c, g, f, a, j;
        if (typeof h == "string") {
            d = h
        } else {
            if (Ext.isArray(h)) {
                for ( var e = 0; e < h.length; e++) {
                    if (h[e]) {
                        d += this.markup(h[e])
                    }
                }
            } else {
                d += "<" + (h.tag = h.tag || "div");
                for (c in h) {
                    if (!h.hasOwnProperty(c)) {
                        continue
                    }
                    g = h[c];
                    if (!this.confRe.test(c)) {
                        if (typeof g == "object") {
                            d += " " + c + '="';
                            for (f in g) {
                                if (!g.hasOwnProperty(f)) {
                                    continue
                                }
                                d += f + ":" + g[f] + ";"
                            }
                            d += '"'
                        } else {
                            d += " " + ({
                                cls : "class",
                                htmlFor : "for"
                            }[c] || c) + '="' + g + '"'
                        }
                    }
                }
                if (this.emptyTags.test(h.tag)) {
                    d += "/>"
                } else {
                    d += ">";
                    if ((j = h.children || h.cn)) {
                        d += this.markup(j)
                    } else {
                        if (h.html) {
                            d += h.html
                        }
                    }
                    d += "</" + h.tag + ">"
                }
            }
        }
        return d
    },
    applyStyles : function(d, e) {
        if (e) {
            var b = 0, a, c;
            d = Ext.fly(d);
            if (typeof e == "function") {
                e = e.call()
            }
            if (typeof e == "string") {
                e = Ext.util.Format.trim(e).split(/\s*(?::|;)\s*/);
                for (a = e.length; b < a;) {
                    d.setStyle(e[b++], e[b++])
                }
            } else {
                if (Ext.isObject(e)) {
                    d.setStyle(e)
                }
            }
        }
    },
    insertHtml : function(f, a, g) {
        var e = {}, c, i, h, j, d, b;
        f = f.toLowerCase();
        e.beforebegin = [ "BeforeBegin", "previousSibling" ];
        e.afterend = [ "AfterEnd", "nextSibling" ];
        h = a.ownerDocument.createRange();
        i = "setStart" + (this.endRe.test(f) ? "After" : "Before");
        if (e[f]) {
            h[i](a);
            j = h.createContextualFragment(g);
            a.parentNode
                    .insertBefore(j, f == "beforebegin" ? a : a.nextSibling);
            return a[(f == "beforebegin" ? "previous" : "next") + "Sibling"]
        } else {
            d = (f == "afterbegin" ? "first" : "last") + "Child";
            if (a.firstChild) {
                h[i](a[d]);
                j = h.createContextualFragment(g);
                if (f == "afterbegin") {
                    a.insertBefore(j, a.firstChild)
                } else {
                    a.appendChild(j)
                }
            } else {
                a.innerHTML = g
            }
            return a[d]
        }
        throw 'Illegal insertion point -> "' + f + '"'
    },
    insertBefore : function(a, c, b) {
        return this.doInsert(a, c, b, "beforebegin")
    },
    insertAfter : function(a, c, b) {
        return this.doInsert(a, c, b, "afterend", "nextSibling")
    },
    insertFirst : function(a, c, b) {
        return this.doInsert(a, c, b, "afterbegin", "firstChild")
    },
    append : function(a, c, b) {
        return this.doInsert(a, c, b, "beforeend", "", true)
    },
    overwrite : function(a, c, b) {
        a = Ext.getDom(a);
        a.innerHTML = this.markup(c);
        return b ? Ext.get(a.firstChild) : a.firstChild
    },
    doInsert : function(d, f, e, g, c, a) {
        var b = this.insertHtml(g, Ext.getDom(d), this.markup(f));
        return e ? Ext.get(b, true) : b
    }
};
Ext.DomQuery = {
    select : function(h, b) {
        var g = [], d, f, e, c, a;
        b = b || document;
        if (typeof b == "string") {
            b = document.getElementById(b)
        }
        h = h.split(",");
        for (f = 0, c = h.length; f < c; f++) {
            if (typeof h[f] == "string") {
                d = b.querySelectorAll(h[f]);
                for (e = 0, a = d.length; e < a; e++) {
                    g.push(d[e])
                }
            }
        }
        return g
    },
    selectNode : function(b, a) {
        return Ext.DomQuery.select(b, a)[0]
    },
    is : function(a, b) {
        if (typeof a == "string") {
            a = document.getElementById(a)
        }
        return Ext.DomQuery.select(b).indexOf(a) !== -1
    }
};
Ext.Element.selectorFunction = Ext.DomQuery.select;
Ext.query = Ext.DomQuery.select;
Ext.Anim = Ext.extend(Object, {
    isAnim : true,
    disableAnimations : false,
    defaultConfig : {
        from : {},
        to : {},
        duration : 250,
        delay : 0,
        easing : "ease-in-out",
        autoClear : true,
        out : true,
        direction : null,
        reverse : false
    },
    opposites : {
        left : "right",
        right : "left",
        up : "down",
        down : "up"
    },
    constructor : function(a) {
        a = Ext.apply({}, a || {}, this.defaultConfig);
        this.config = a;
        Ext.Anim.superclass.constructor.call(this);
        this.running = {}
    },
    initConfig : function(c, b) {
        var e = this, d = {}, a = Ext.apply({}, b || {}, e.config);
        a.el = c = Ext.get(c);
        if (a.reverse && e.opposites[a.direction]) {
            a.direction = e.opposites[a.direction]
        }
        if (e.config.before) {
            e.config.before.call(a, c, a)
        }
        if (b.before) {
            b.before.call(a.scope || a, c, a)
        }
        return a
    },
    run : function(c, a) {
        c = Ext.get(c);
        a = a || {};
        var d = this, b = c.dom.style, e, f = a.after;
        if (d.running[c.id]) {
            d.onTransitionEnd(null, c, {
                config : a,
                after : f
            })
        }
        a = this.initConfig(c, a);
        if (this.disableAnimations) {
            for (e in a.to) {
                if (!a.to.hasOwnProperty(e)) {
                    continue
                }
                b[e] = a.to[e]
            }
            this.onTransitionEnd(null, c, {
                config : a,
                after : f
            });
            return d
        }
        c.un("webkitTransitionEnd", d.onTransitionEnd, d);
        b.webkitTransitionDuration = "0ms";
        for (e in a.from) {
            if (!a.from.hasOwnProperty(e)) {
                continue
            }
            b[e] = a.from[e]
        }
        setTimeout(function() {
            if (!c.dom) {
                return
            }
            if (a.is3d === true) {
                c.parent().setStyle({
                    "-webkit-perspective" : "1200",
                    "-webkit-transform-style" : "preserve-3d"
                })
            }
            b.webkitTransitionDuration = a.duration + "ms";
            b.webkitTransitionProperty = "all";
            b.webkitTransitionTimingFunction = a.easing;
            c.on("webkitTransitionEnd", d.onTransitionEnd, d, {
                config : a,
                after : f
            });
            for (e in a.to) {
                if (!a.to.hasOwnProperty(e)) {
                    continue
                }
                b[e] = a.to[e]
            }
        }, a.delay || 5);
        d.running[c.id] = a;
        return d
    },
    onTransitionEnd : function(e, c, g) {
        c = Ext.get(c);
        if (this.running[c.id] === undefined) {
            return
        }
        var b = c.dom.style, a = g.config, f, d = this;
        c.un("webkitTransitionEnd", d.onTransitionEnd, d);
        if (a.autoClear) {
            for (f in a.to) {
                if (!a.to.hasOwnProperty(f)) {
                    continue
                }
                b[f] = ""
            }
        }
        b.webkitTransitionDuration = null;
        b.webkitTransitionProperty = null;
        b.webkitTransitionTimingFunction = null;
        if (a.is3d) {
            c.parent().setStyle({
                "-webkit-perspective" : "",
                "-webkit-transform-style" : ""
            })
        }
        if (d.config.after) {
            d.config.after.call(a, c, a)
        }
        if (g.after) {
            g.after.call(a.scope || d, c, a)
        }
        delete d.running[c.id]
    }
});
Ext.Anim.seed = 1000;
Ext.Anim.run = function(b, c, a) {
    if (b.isComponent) {
        b = b.el
    }
    a = a || {};
    if (c.isAnim) {
        c.run(b, a)
    } else {
        if (Ext.isObject(c)) {
            if (a.before && c.before) {
                a.before = Ext.createInterceptor(a.before, c.before, c.scope)
            }
            if (a.after && c.after) {
                a.after = Ext.createInterceptor(a.after, c.after, c.scope)
            }
            a = Ext.apply({}, a, c);
            c = c.type
        }
        if (!Ext.anims[c]) {
            throw c + " is not a valid animation type."
        } else {
            if (b && b.dom) {
                Ext.anims[c].run(b, a)
            }
        }
    }
};
Ext.anims = {
    fade : new Ext.Anim({
        before : function(b) {
            var c = 1, a = 1, e = b.getStyle("z-index") == "auto" ? 0 : b
                    .getStyle("z-index"), d = e;
            if (this.out) {
                a = 0
            } else {
                d = e + 1;
                c = 0
            }
            this.from = {
                opacity : c,
                "z-index" : d
            };
            this.to = {
                opacity : a,
                "z-index" : d
            }
        }
    }),
    slide : new Ext.Anim(
            {
                direction : "left",
                cover : false,
                reveal : false,
                before : function(b) {
                    var a = b.getStyle("z-index") == "auto" ? 0 : b
                            .getStyle("z-index"), e = a + 1, h = 0, f = 0, i = 0, g = 0, c = b
                            .getHeight(), d = b.getWidth();
                    if (this.direction == "left" || this.direction == "right") {
                        if (this.out == true) {
                            h = -d
                        } else {
                            i = d
                        }
                    } else {
                        if (this.direction == "up" || this.direction == "down") {
                            if (this.out == true) {
                                f = -c
                            } else {
                                g = c
                            }
                        }
                    }
                    if (this.direction == "right" || this.direction == "down") {
                        f *= -1;
                        h *= -1;
                        g *= -1;
                        i *= -1
                    }
                    if (this.cover && this.out) {
                        h = 0;
                        f = 0;
                        e = a
                    } else {
                        if (this.reveal && !this.out) {
                            i = 0;
                            g = 0;
                            e = a
                        }
                    }
                    this.from = {
                        "-webkit-transform" : "translate3d(" + i + "px, " + g
                                + "px, 0)",
                        "z-index" : e,
                        opacity : 0.99
                    };
                    this.to = {
                        "-webkit-transform" : "translate3d(" + h + "px, " + f
                                + "px, 0)",
                        "z-index" : e,
                        opacity : 1
                    }
                }
            }),
    pop : new Ext.Anim(
            {
                scaleOnExit : true,
                before : function(d) {
                    var b = 1, c = 1, g = 1, a = 1, h = d.getStyle("z-index") == "auto" ? 0
                            : d.getStyle("z-index"), f = h, e = h;
                    if (!this.out) {
                        b = 0.01;
                        f = h + 1;
                        e = h + 1;
                        g = 0
                    } else {
                        if (this.scaleOnExit) {
                            c = 0.01;
                            a = 0
                        } else {
                            a = 0.8
                        }
                    }
                    this.from = {
                        "-webkit-transform" : "scale(" + b + ")",
                        "-webkit-transform-origin" : "50% 50%",
                        opacity : g,
                        "z-index" : f
                    };
                    this.to = {
                        "-webkit-transform" : "scale(" + c + ")",
                        "-webkit-transform-origin" : "50% 50%",
                        opacity : a,
                        "z-index" : e
                    }
                }
            })
};
Ext
        .apply(
                Ext.anims,
                {
                    flip : new Ext.Anim({
                        is3d : true,
                        direction : "left",
                        before : function(c) {
                            var f = "Y", a = 1, b = 1, e = 0, d = 0;
                            if (this.out) {
                                d = -180;
                                b = 0.8
                            } else {
                                e = 180;
                                a = 0.8
                            }
                            if (this.direction == "up"
                                    || this.direction == "down") {
                                f = "X"
                            }
                            if (this.direction == "right"
                                    || this.direction == "left") {
                                d *= -1;
                                e *= -1
                            }
                            this.from = {
                                "-webkit-transform" : "rotate" + f + "(" + e
                                        + "deg) scale(" + a + ")",
                                "-webkit-backface-visibility" : "hidden"
                            };
                            this.to = {
                                "-webkit-transform" : "rotate" + f + "(" + d
                                        + "deg) scale(" + b + ")",
                                "-webkit-backface-visibility" : "hidden"
                            }
                        }
                    }),
                    cube : new Ext.Anim(
                            {
                                is3d : true,
                                direction : "left",
                                style : "outer",
                                before : function(b) {
                                    var n = "0% 0%", o = 0, a = 0, k = "Y", h = 0, i = 0, l = 1, e = 1, g, f = b
                                            .getWidth(), d = b.getHeight(), m = true, c = " translateX(0)", j = "";
                                    if (this.direction == "left"
                                            || this.direction == "right") {
                                        if (this.out) {
                                            n = "100% 100%";
                                            i = f;
                                            e = 0.5;
                                            a = -90
                                        } else {
                                            n = "0% 0%";
                                            h = f;
                                            l = 0.5;
                                            o = 90
                                        }
                                    } else {
                                        if (this.direction == "up"
                                                || this.direction == "down") {
                                            k = "X";
                                            if (this.out) {
                                                n = "100% 100%";
                                                i = d;
                                                a = 90
                                            } else {
                                                n = "0% 0%";
                                                h = d;
                                                o = -90
                                            }
                                        }
                                    }
                                    if (this.direction == "down"
                                            || this.direction == "right") {
                                        o *= -1;
                                        a *= -1;
                                        n = (n == "0% 0%") ? "100% 100%"
                                                : "0% 0%"
                                    }
                                    if (this.style == "inner") {
                                        h *= -1;
                                        i *= -1;
                                        o *= -1;
                                        a *= -1;
                                        if (!this.out) {
                                            j = " translateX(0px)";
                                            n = "0% 50%"
                                        } else {
                                            j = c;
                                            n = "100% 50%"
                                        }
                                    }
                                    this.from = {
                                        "-webkit-transform" : "rotate"
                                                + k
                                                + "("
                                                + o
                                                + "deg)"
                                                + (m ? " translateZ(" + h
                                                        + "px)" : "") + c,
                                        "-webkit-transform-origin" : n
                                    };
                                    this.to = {
                                        "-webkit-transform" : "rotate" + k
                                                + "(" + a + "deg) translateZ("
                                                + i + "px)" + j,
                                        "-webkit-transform-origin" : n
                                    }
                                },
                                duration : 250
                            }),
                    wipe : new Ext.Anim(
                            {
                                before : function(d) {
                                    var e = d.getStyle("z-index"), a = "", b = "100%", c = "100%";
                                    if (!this.out) {
                                        zIndex = e + 1;
                                        a = "-webkit-gradient(linear, left bottom, right bottom, from(transparent), to(#000), color-stop(66%, #000), color-stop(33%, transparent))";
                                        b = d.getHeight() * 100 + "px";
                                        c = d.getHeight();
                                        this.from = {
                                            "-webkit-mask-image" : a,
                                            "-webkit-mask-size" : d.getWidth()
                                                    * 3 + "px " + d.getHeight()
                                                    + "px",
                                            "z-index" : zIndex,
                                            "-webkit-mask-position-x" : 0
                                        };
                                        this.to = {
                                            "-webkit-mask-image" : a,
                                            "-webkit-mask-size" : d.getWidth()
                                                    * 3 + "px " + d.getHeight()
                                                    + "px",
                                            "z-index" : zIndex,
                                            "-webkit-mask-position-x" : -d
                                                    .getWidth()
                                                    * 2 + "px"
                                        }
                                    }
                                },
                                duration : 500
                            })
                });
Ext
        .apply(
                Ext,
                {
                    version : "1.1.1",
                    versionDetail : {
                        major : 1,
                        minor : 1,
                        patch : 1
                    },
                    setup : function(a) {
                        if (a && typeof a == "object") {
                            if (a.addMetaTags !== false) {
                                this.addMetaTags(a)
                            }
                            if (Ext.isFunction(a.onReady)) {
                                var b = this;
                                Ext.onReady(function() {
                                    var c = arguments;
                                    if (a.fullscreen !== false) {
                                        Ext.Viewport.init(function() {
                                            a.onReady.apply(b, c)
                                        })
                                    } else {
                                        a.onReady.apply(this, c)
                                    }
                                }, a.scope)
                            }
                        }
                    },
                    getDom : function(a) {
                        if (!a || !document) {
                            return null
                        }
                        return a.dom ? a.dom : (typeof a == "string" ? document
                                .getElementById(a) : a)
                    },
                    removeNode : function(a) {
                        if (a && a.parentNode && a.tagName != "BODY") {
                            Ext.EventManager.removeAll(a);
                            a.parentNode.removeChild(a);
                            delete Ext.cache[a.id]
                        }
                    },
                    addMetaTags : function(b) {
                        if (!Ext.isObject(b)) {
                            return
                        }
                        var c = Ext
                                .get(document.getElementsByTagName("head")[0]), a, d;
                        if (!Ext.is.Desktop) {
                            a = Ext.get(document.createElement("meta"));
                            a
                                    .set({
                                        name : "viewport",
                                        content : "width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0;"
                                    });
                            c.appendChild(a)
                        }
                        if (Ext.is.iOS) {
                            if (b.fullscreen !== false) {
                                a = Ext.get(document.createElement("meta"));
                                a.set({
                                    name : "apple-mobile-web-app-capable",
                                    content : "yes"
                                });
                                c.appendChild(a);
                                if (Ext.isString(b.statusBarStyle)) {
                                    a = Ext.get(document.createElement("meta"));
                                    a
                                            .set({
                                                name : "apple-mobile-web-app-status-bar-style",
                                                content : b.statusBarStyle
                                            });
                                    c.appendChild(a)
                                }
                            }
                            if (b.tabletStartupScreen && Ext.is.iPad) {
                                a = Ext.get(document.createElement("link"));
                                a.set({
                                    rel : "apple-touch-startup-image",
                                    href : b.tabletStartupScreen
                                });
                                c.appendChild(a)
                            }
                            if (b.phoneStartupScreen && !Ext.is.iPad) {
                                a = Ext.get(document.createElement("link"));
                                a.set({
                                    rel : "apple-touch-startup-image",
                                    href : b.phoneStartupScreen
                                });
                                c.appendChild(a)
                            }
                            if (b.icon) {
                                b.phoneIcon = b.tabletIcon = b.icon
                            }
                            d = (b.glossOnIcon === false) ? "-precomposed" : "";
                            if (Ext.is.iPad && Ext.isString(b.tabletIcon)) {
                                a = Ext.get(document.createElement("link"));
                                a.set({
                                    rel : "apple-touch-icon" + d,
                                    href : b.tabletIcon
                                });
                                c.appendChild(a)
                            } else {
                                if (!Ext.is.iPad && Ext.isString(b.phoneIcon)) {
                                    a = Ext.get(document.createElement("link"));
                                    a.set({
                                        rel : "apple-touch-icon" + d,
                                        href : b.phoneIcon
                                    });
                                    c.appendChild(a)
                                }
                            }
                        }
                    }
                });
(function() {
    var a = function() {
        var c = Ext.getBody(), b = [];
        if (!c) {
            return false
        }
        var d = Ext.is;
        if (d.Phone) {
            b.push("x-phone")
        } else {
            if (d.Tablet) {
                b.push("x-tablet")
            } else {
                if (d.Desktop) {
                    b.push("x-desktop")
                }
            }
        }
        if (d.iPad) {
            b.push("x-ipad")
        }
        if (d.iOS) {
            b.push("x-ios")
        }
        if (d.Android) {
            b.push("x-android", "x-android-" + d.AndroidMajorVersion)
        }
        if (d.Blackberry) {
            b.push("x-bb")
        }
        if (d.Standalone) {
            b.push("x-standalone")
        }
        if (b.length) {
            c.addCls(b)
        }
        return true
    };
    if (!a()) {
        Ext.onReady(a)
    }
})();
Ext.Viewport = new (Ext
        .extend(
                Ext.util.Observable,
                {
                    constructor : function() {
                        var a = this;
                        this.addEvents("orientationchange", "resize");
                        this.stretchSizes = {};
                        if (Ext.supports.OrientationChange) {
                            window.addEventListener("orientationchange", Ext
                                    .createDelegate(a.onOrientationChange, a),
                                    false)
                        } else {
                            window.addEventListener("resize", Ext
                                    .createDelegate(a.onResize, a), false)
                        }
                        if (!Ext.desktop) {
                            document.addEventListener("touchstart",
                                    Ext.createDelegate(a.onTouchStartCapturing,
                                            a), true)
                        }
                    },
                    init : function(c, b) {
                        var d = this, e = Math.max(window.innerHeight,
                                window.innerWidth) * 2, a = Ext.getBody();
                        d.updateOrientation();
                        this.initialHeight = window.innerHeight;
                        this.initialOrientation = this.orientation;
                        a.setHeight(e);
                        Ext.gesture.Manager.freeze();
                        this.scrollToTop();
                        setTimeout(function() {
                            d.scrollToTop();
                            setTimeout(function() {
                                d.scrollToTop();
                                d.initialHeight = Math.max(d.initialHeight,
                                        window.innerHeight);
                                if (c) {
                                    c.apply(b || window)
                                }
                                d.updateBodySize();
                                Ext.gesture.Manager.thaw()
                            }, 500)
                        }, 500)
                    },
                    scrollToTop : function() {
                        if (Ext.is.iOS) {
                            if (Ext.is.Phone) {
                                document.body.scrollTop = document.body.scrollHeight
                            }
                        } else {
                            if (Ext.is.Blackberry) {
                                window.scrollTo(0, 1000)
                            } else {
                                window.scrollTo(0, 1)
                            }
                        }
                    },
                    updateBodySize : function() {
                        Ext.getBody().setSize(window.innerWidth,
                                window.innerHeight)
                    },
                    updateOrientation : function() {
                        this.lastSize = this.getSize();
                        this.orientation = this.getOrientation()
                    },
                    onTouchStartCapturing : function(a) {
                        if (!Ext.currentlyFocusedField && Ext.is.iOS) {
                            this.scrollToTop()
                        }
                    },
                    onOrientationChange : function() {
                        var b = this, a = Ext.getBody();
                        if (!Ext.is.Phone) {
                            a.setHeight(a.getWidth());
                            this.updateOrientation();
                            this.fireEvent("orientationchange", this,
                                    this.orientation);
                            b.scrollToTop();
                            b.updateBodySize();
                            b.fireResizeEvent();
                            Ext.repaint();
                            return
                        }
                        Ext.gesture.Manager.freeze();
                        a.setHeight(a.getWidth());
                        this.updateOrientation();
                        this.fireEvent("orientationchange", this,
                                this.orientation);
                        setTimeout(function() {
                            b.scrollToTop();
                            setTimeout(function() {
                                b.updateBodySize();
                                b.fireResizeEvent();
                                Ext.gesture.Manager.thaw();
                                Ext.repaint()
                            }, 200)
                        }, 200)
                    },
                    fireResizeEvent : function() {
                        var a = this;
                        if (!Ext.is.iOS) {
                            if (this.resizeEventTimer) {
                                clearTimeout(this.resizeEventTimer)
                            }
                            this.resizeEventTimer = setTimeout(function() {
                                a.fireEvent("resize", a, a.getSize())
                            }, 500)
                        } else {
                            a.fireEvent("resize", a, a.getSize())
                        }
                    },
                    onResize : function() {
                        if (this.orientation != this.getOrientation()) {
                            this.onOrientationChange()
                        } else {
                            var a = this.getSize();
                            if (!Ext.is.iOS && !Ext.is.Desktop) {
                                if ((a.width == this.lastSize.width && a.height > this.lastSize.height)
                                        || (a.height == this.lastSize.height && a.width > this.lastSize.width)) {
                                    this.fireEvent("resize", this, a)
                                }
                            } else {
                                this.fireEvent("resize", this, a)
                            }
                        }
                    },
                    getSize : function() {
                        var a = {
                            width : window.innerWidth,
                            height : window.innerHeight
                        };
                        if (!Ext.is.Desktop) {
                            a.height = (this.orientation == this.initialOrientation) ? Math
                                    .max(this.initialHeight, a.height)
                                    : a.height
                        }
                        return a
                    },
                    getOffset : function() {
                        return {
                            x : window.pageXOffset,
                            y : window.pageYOffset
                        }
                    },
                    getOrientation : function() {
                        var d = this, b = d.getSize(), c, a;
                        if (window.hasOwnProperty("orientation")) {
                            a = window.orientation;
                            c = Ext.is.Android
                                    && Ext.is.AndroidMajorVersion === 3;
                            if (a % 180 === 0) {
                                return c ? "landscape" : "portrait"
                            } else {
                                return c ? "portrait" : "landscape"
                            }
                        } else {
                            if (!Ext.is.iOS && !Ext.is.Desktop) {
                                if ((b.width == d.lastSize.width && b.height < d.lastSize.height)
                                        || (b.height == d.lastSize.height && b.width < d.lastSize.width)) {
                                    return d.orientation
                                }
                            }
                            return (window.innerHeight > window.innerWidth) ? "portrait"
                                    : "landscape"
                        }
                    }
                }));
Ext.util.TapRepeater = Ext.extend(Ext.util.Observable, {
    constructor : function(b, a) {
        this.el = Ext.get(b);
        Ext.apply(this, a);
        this.addEvents("touchstart", "tap", "touchend");
        this.el.on({
            touchstart : this.onTouchStart,
            touchend : this.onTouchEnd,
            scope : this
        });
        if (this.preventDefault || this.stopDefault) {
            this.el.on("tap", this.eventOptions, this)
        }
        Ext.util.TapRepeater.superclass.constructor.call(this)
    },
    interval : 10,
    delay : 250,
    preventDefault : true,
    stopDefault : false,
    timer : 0,
    eventOptions : function(a) {
        if (this.preventDefault) {
            a.preventDefault()
        }
        if (this.stopDefault) {
            a.stopEvent()
        }
    },
    destroy : function() {
        Ext.destroy(this.el);
        this.clearListeners()
    },
    onTouchStart : function(a) {
        clearTimeout(this.timer);
        if (this.pressClass) {
            this.el.addCls(this.pressClass)
        }
        this.tapStartTime = new Date();
        this.fireEvent("touchstart", this, a);
        this.fireEvent("tap", this, a);
        if (this.accelerate) {
            this.delay = 400
        }
        this.timer = Ext.defer(this.tap, this.delay || this.interval, this,
                [ a ])
    },
    tap : function(a) {
        this.fireEvent("tap", this, a);
        this.timer = Ext.defer(this.tap, this.accelerate ? this.easeOutExpo(
                Ext.util.Date.getElapsed(this.tapStartTime), 400, -390, 12000)
                : this.interval, this, [ a ])
    },
    easeOutExpo : function(e, a, g, f) {
        return (e == f) ? a + g : g * (-Math.pow(2, -10 * e / f) + 1) + a
    },
    onTouchEnd : function(a) {
        clearTimeout(this.timer);
        this.el.removeCls(this.pressClass);
        this.fireEvent("touchend", this, a)
    }
});
if (!this.JSON) {
    this.JSON = {}
}
(function() {
    function f(n) {
        return n < 10 ? "0" + n : n
    }
    if (typeof Date.prototype.toJSON !== "function") {
        Date.prototype.toJSON = function(key) {
            return isFinite(this.valueOf()) ? this.getUTCFullYear() + "-"
                    + f(this.getUTCMonth() + 1) + "-" + f(this.getUTCDate())
                    + "T" + f(this.getUTCHours()) + ":"
                    + f(this.getUTCMinutes()) + ":" + f(this.getUTCSeconds())
                    + "Z" : null
        };
        String.prototype.toJSON = Number.prototype.toJSON = Boolean.prototype.toJSON = function(
                key) {
            return this.valueOf()
        }
    }
    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = {
        "\b" : "\\b",
        "\t" : "\\t",
        "\n" : "\\n",
        "\f" : "\\f",
        "\r" : "\\r",
        '"' : '\\"',
        "\\" : "\\\\"
    }, rep;
    function quote(string) {
        escapable.lastIndex = 0;
        return escapable.test(string) ? '"'
                + string.replace(escapable, function(a) {
                    var c = meta[a];
                    return typeof c === "string" ? c : "\\u"
                            + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
                }) + '"' : '"' + string + '"'
    }
    function str(key, holder) {
        var i, k, v, length, mind = gap, partial, value = holder[key];
        if (value && typeof value === "object"
                && typeof value.toJSON === "function") {
            value = value.toJSON(key)
        }
        if (typeof rep === "function") {
            value = rep.call(holder, key, value)
        }
        switch (typeof value) {
        case "string":
            return quote(value);
        case "number":
            return isFinite(value) ? String(value) : "null";
        case "boolean":
        case "null":
            return String(value);
        case "object":
            if (!value) {
                return "null"
            }
            gap += indent;
            partial = [];
            if (Object.prototype.toString.apply(value) === "[object Array]") {
                length = value.length;
                for (i = 0; i < length; i += 1) {
                    partial[i] = str(i, value) || "null"
                }
                v = partial.length === 0 ? "[]" : gap ? "[\n" + gap
                        + partial.join(",\n" + gap) + "\n" + mind + "]" : "["
                        + partial.join(",") + "]";
                gap = mind;
                return v
            }
            if (rep && typeof rep === "object") {
                length = rep.length;
                for (i = 0; i < length; i += 1) {
                    k = rep[i];
                    if (typeof k === "string") {
                        v = str(k, value);
                        if (v) {
                            partial.push(quote(k) + (gap ? ": " : ":") + v)
                        }
                    }
                }
            } else {
                for (k in value) {
                    if (Object.hasOwnProperty.call(value, k)) {
                        v = str(k, value);
                        if (v) {
                            partial.push(quote(k) + (gap ? ": " : ":") + v)
                        }
                    }
                }
            }
            v = partial.length === 0 ? "{}" : gap ? "{\n" + gap
                    + partial.join(",\n" + gap) + "\n" + mind + "}" : "{"
                    + partial.join(",") + "}";
            gap = mind;
            return v
        }
        return v
    }
    if (typeof JSON.stringify !== "function") {
        JSON.stringify = function(value, replacer, space) {
            var i;
            gap = "";
            indent = "";
            if (typeof space === "number") {
                for (i = 0; i < space; i += 1) {
                    indent += " "
                }
            } else {
                if (typeof space === "string") {
                    indent = space
                }
            }
            rep = replacer;
            if (replacer
                    && typeof replacer !== "function"
                    && (typeof replacer !== "object" || typeof replacer.length !== "number")) {
                throw new Error("JSON.stringify")
            }
            return str("", {
                "" : value
            })
        }
    }
    if (typeof JSON.parse !== "function") {
        JSON.parse = function(text, reviver) {
            var j;
            function walk(holder, key) {
                var k, v, value = holder[key];
                if (value && typeof value === "object") {
                    for (k in value) {
                        if (Object.hasOwnProperty.call(value, k)) {
                            v = walk(value, k);
                            if (v !== undefined) {
                                value[k] = v
                            } else {
                                delete value[k]
                            }
                        }
                    }
                }
                return reviver.call(holder, key, value)
            }
            text = String(text);
            cx.lastIndex = 0;
            if (cx.test(text)) {
                text = text.replace(cx, function(a) {
                    return "\\u"
                            + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
                })
            }
            if (/^[\],:{}\s]*$/
                    .test(text
                            .replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
                            .replace(
                                    /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
                                    "]").replace(/(?:^|:|,)(?:\s*\[)+/g, ""))) {
                j = eval("(" + text + ")");
                return typeof reviver === "function" ? walk({
                    "" : j
                }, "") : j
            }
            throw new SyntaxError("JSON.parse")
        }
    }
}());
Ext.util.JSON = {
    encode : function(a) {
        return JSON.stringify(a)
    },
    decode : function(a) {
        return JSON.parse(a)
    }
};
Ext.encode = Ext.util.JSON.encode;
Ext.decode = Ext.util.JSON.decode;
Ext.util.JSONP = {
    queue : [],
    current : null,
    request : function(d) {
        d = d || {};
        if (!d.url) {
            return
        }
        var b = this;
        d.params = d.params || {};
        if (d.callbackKey) {
            d.params[d.callbackKey] = "Ext.util.JSONP.callback"
        }
        var c = Ext.urlEncode(d.params);
        var a = document.createElement("script");
        a.type = "text/javascript";
        this.queue.push({
            url : d.url,
            script : a,
            callback : d.callback || function() {
            },
            scope : d.scope || window,
            params : c || null
        });
        if (!this.current) {
            this.next()
        }
    },
    next : function() {
        this.current = null;
        if (this.queue.length) {
            this.current = this.queue.shift();
            this.current.script.src = this.current.url
                    + (this.current.params ? ("?" + this.current.params) : "");
            document.getElementsByTagName("head")[0]
                    .appendChild(this.current.script)
        }
    },
    callback : function(a) {
        this.current.callback.call(this.current.scope, a);
        document.getElementsByTagName("head")[0]
                .removeChild(this.current.script);
        this.next()
    }
};
Ext.util.Draggable = Ext
        .extend(
                Ext.util.Observable,
                {
                    baseCls : "x-draggable",
                    draggingCls : "x-dragging",
                    proxyCls : "x-draggable-proxy",
                    outOfBoundRestrictFactor : 1,
                    direction : "both",
                    fps : Ext.is.Blackberry ? 25
                            : ((Ext.is.iOS || Ext.is.Desktop) ? 80 : 50),
                    constrain : window,
                    threshold : 0,
                    delay : 0,
                    cancelSelector : null,
                    disabled : false,
                    revert : false,
                    group : "base",
                    useCssTransform : true,
                    grid : null,
                    snap : null,
                    proxy : null,
                    stack : false,
                    animationDuration : 300,
                    updateBoundaryOnTouchStart : true,
                    offsetBoundary : null,
                    dragging : false,
                    vertical : false,
                    horizontal : false,
                    monitorOrientation : true,
                    constructor : function(b, a) {
                        this.el = Ext.get(b);
                        this.id = b.id;
                        a = a || {};
                        Ext.apply(this, a);
                        this.addEvents("offsetchange", "offsetboundaryupdate");
                        Ext.util.Draggable.superclass.constructor.call(this, a);
                        if (this.eventTarget === "parent") {
                            this.eventTarget = this.el.parent()
                        } else {
                            this.eventTarget = (this.eventTarget) ? Ext
                                    .get(this.eventTarget) : this.el
                        }
                        if (this.direction == "both") {
                            this.horizontal = true;
                            this.vertical = true
                        } else {
                            if (this.direction == "horizontal") {
                                this.horizontal = true
                            } else {
                                this.vertical = true
                            }
                        }
                        this.el.addCls(this.baseCls);
                        if (this.proxy) {
                            this.getProxyEl().addCls(this.proxyCls)
                        }
                        this.startEventName = (this.delay > 0) ? "taphold"
                                : "dragstart";
                        this.dragOptions = (this.delay > 0) ? {
                            holdThreshold : this.delay
                        } : {
                            direction : this.direction,
                            dragThreshold : this.threshold
                        };
                        this.container = window;
                        if (this.constrain) {
                            if (this.constrain === "parent") {
                                this.container = this.el.parent()
                            } else {
                                if (this.constrain !== window) {
                                    this.container = Ext.get(this.constrain)
                                }
                            }
                        }
                        this.offset = new Ext.util.Offset();
                        this.linearAnimation = {
                            x : new Ext.util.Draggable.Animation.Linear(),
                            y : new Ext.util.Draggable.Animation.Linear()
                        };
                        this.updateBoundary(true);
                        this.setDragging(false);
                        if (!this.disabled) {
                            this.enable()
                        }
                        return this
                    },
                    enable : function() {
                        return this.setEnabled(true)
                    },
                    disable : function() {
                        return this.setEnabled(false)
                    },
                    setEnabled : function(a) {
                        this.eventTarget[a ? "on" : "un"](this.startEventName,
                                this.onStart, this, this.dragOptions);
                        this.eventTarget[a ? "on" : "un"]("drag", this.onDrag,
                                this, this.dragOptions);
                        this.eventTarget[a ? "on" : "un"]("dragend",
                                this.onDragEnd, this, this.dragOptions);
                        this.eventTarget[a ? "on" : "un"]("touchstart",
                                this.onTouchStart, this);
                        if (a) {
                            Ext.EventManager.onOrientationChange(
                                    this.onOrientationChange, this)
                        } else {
                            Ext.EventManager.orientationEvent.removeListener(
                                    this.onOrientationChange, this)
                        }
                        this.disabled = !a;
                        return this
                    },
                    setUseCssTransform : function(a) {
                        if (typeof a == "undefined") {
                            a = true
                        }
                        if (a != this.useCssTransform) {
                            this.useCssTransform = a;
                            var b = new Ext.util.Offset();
                            if (a == false) {
                                this.setStyleOffset(this.offset);
                                this.setTransformOffset(b, true)
                            } else {
                                this.setTransformOffset(this.offset);
                                this.setStyleOffset(b)
                            }
                        }
                        return this
                    },
                    setOffset : function(b, a) {
                        if (!this.horizontal) {
                            b.x = 0
                        }
                        if (!this.vertical) {
                            b.y = 0
                        }
                        if (!(b instanceof Ext.util.Offset)) {
                            b = Ext.util.Offset.fromObject(b)
                        }
                        b.round();
                        if (!this.offset.equals(b)) {
                            if (a) {
                                this.startAnimation(b, a)
                            } else {
                                this.offset = b;
                                this.region = new Ext.util.Region(
                                        this.initialRegion.top + b.y,
                                        this.initialRegion.right + b.x,
                                        this.initialRegion.bottom + b.y,
                                        this.initialRegion.left + b.x);
                                if (this.useCssTransform) {
                                    this.setTransformOffset(b)
                                } else {
                                    this.setStyleOffset(b)
                                }
                                this.fireEvent("offsetchange", this,
                                        this.offset)
                            }
                        }
                        return this
                    },
                    setTransformOffset : function(b, a) {
                        if (a) {
                            this.getProxyEl().dom.style.webkitTransform = ""
                        } else {
                            Ext.Element.cssTranslate(this.getProxyEl(), b)
                        }
                        return this
                    },
                    setStyleOffset : function(b) {
                        var a = this.getProxyEl();
                        a.dom.style.left = b.x + "px";
                        a.dom.style.top = b.y + "px";
                        return this
                    },
                    startAnimation : function(d, a) {
                        var c = this;
                        this.stopAnimation();
                        var b = Date.now();
                        a = Ext.isNumber(a) ? a : this.animationDuration;
                        this.linearAnimation.x.set({
                            startOffset : this.offset.x,
                            endOffset : d.x,
                            startTime : b,
                            duration : a
                        });
                        this.linearAnimation.y.set({
                            startOffset : this.offset.y,
                            endOffset : d.y,
                            startTime : b,
                            duration : a
                        });
                        this.isAnimating = true;
                        this.animationTimer = setInterval(function() {
                            c.handleAnimationFrame()
                        }, this.getFrameDuration());
                        return this
                    },
                    getFrameDuration : function() {
                        return 1000 / this.fps
                    },
                    stopAnimation : function() {
                        if (this.isAnimating) {
                            clearInterval(this.animationTimer);
                            this.isAnimating = false;
                            this.setDragging(false)
                        }
                        return this
                    },
                    handleAnimationFrame : function() {
                        if (!this.isAnimating) {
                            return
                        }
                        var a = new Ext.util.Offset();
                        a.x = this.linearAnimation.x.getOffset();
                        a.y = this.linearAnimation.y.getOffset();
                        this.setOffset(a);
                        if ((a.x === this.linearAnimation.x.endOffset)
                                && (a.y === this.linearAnimation.y.endOffset)) {
                            this.stopAnimation()
                        }
                    },
                    getOffset : function() {
                        var a = this.offset.copy();
                        a.y = -a.y;
                        a.x = -a.x;
                        return a
                    },
                    updateBoundary : function(f) {
                        var h;
                        if (typeof f == "undefined") {
                            f = false
                        }
                        this.size = {
                            width : this.el.dom.scrollWidth,
                            height : this.el.dom.scrollHeight
                        };
                        if (this.container === window) {
                            this.containerBox = {
                                left : 0,
                                top : 0,
                                right : this.container.innerWidth,
                                bottom : this.container.innerHeight,
                                width : this.container.innerWidth,
                                height : this.container.innerHeight
                            }
                        } else {
                            this.containerBox = this.container.getPageBox()
                        }
                        var a = this.el.getXY();
                        this.elBox = {
                            left : a[0] - this.offset.x,
                            top : a[1] - this.offset.y,
                            width : this.size.width,
                            height : this.size.height
                        };
                        this.elBox.bottom = this.elBox.top + this.elBox.height;
                        this.elBox.right = this.elBox.left + this.elBox.width;
                        this.initialRegion = this.region = new Ext.util.Region(
                                a[1], a[0] + this.elBox.width, a[1]
                                        + this.elBox.height, a[0]);
                        var e = 0, c = 0, b = 0, d = 0;
                        if (this.elBox.left < this.containerBox.left) {
                            c += this.containerBox.left - this.elBox.left
                        } else {
                            d -= this.elBox.left - this.containerBox.left
                        }
                        if (this.elBox.right > this.containerBox.right) {
                            d -= this.elBox.right - this.containerBox.right
                        } else {
                            c += this.containerBox.right - this.elBox.right
                        }
                        if (this.elBox.top < this.containerBox.top) {
                            b += this.containerBox.top - this.elBox.top
                        } else {
                            e -= this.elBox.top - this.containerBox.top
                        }
                        if (this.elBox.bottom > this.containerBox.bottom) {
                            e -= this.elBox.bottom - this.containerBox.bottom
                        } else {
                            b += this.containerBox.bottom - this.elBox.bottom
                        }
                        h = new Ext.util.Region(e, c, b, d).round();
                        if (this.offsetBoundary
                                && this.offsetBoundary.equals(h)) {
                            return this
                        }
                        this.offsetBoundary = h;
                        this.fireEvent("offsetboundaryupdate", this,
                                this.offsetBoundary);
                        var g;
                        if (this.useCssTransform) {
                            g = Ext.Element.getComputedTransformOffset(this
                                    .getProxyEl());
                            if (!this.offset.equals(g) || f) {
                                this.setOffset(g)
                            }
                        }
                        return this
                    },
                    onTouchStart : function() {
                    },
                    onStart : function(a) {
                        if (this.updateBoundaryOnTouchStart) {
                            this.updateBoundary()
                        }
                        this.stopAnimation();
                        this.setDragging(true);
                        this.startTouchPoint = new Ext.util.Point(a.startX,
                                a.startY);
                        this.startOffset = this.offset.copy();
                        this.fireEvent("dragstart", this, a);
                        return true
                    },
                    getNewOffsetFromTouchPoint : function(a) {
                        var c = a.x - this.startTouchPoint.x, b = a.y
                                - this.startTouchPoint.y, d = this.offset
                                .copy();
                        if (c == 0 && b == 0) {
                            return d
                        }
                        if (this.horizontal) {
                            d.x = this.startOffset.x + c
                        }
                        if (this.vertical) {
                            d.y = this.startOffset.y + b
                        }
                        return d
                    },
                    onDrag : function(a) {
                        if (!this.dragging) {
                            return
                        }
                        this.lastTouchPoint = Ext.util.Point.fromEvent(a);
                        var b = this
                                .getNewOffsetFromTouchPoint(this.lastTouchPoint);
                        if (this.offsetBoundary != null) {
                            b = this.offsetBoundary.restrict(b,
                                    this.outOfBoundRestrictFactor)
                        }
                        this.setOffset(b);
                        this.fireEvent("drag", this, a);
                        return true
                    },
                    onDragEnd : function(a) {
                        if (this.dragging) {
                            this.fireEvent("beforedragend", this, a);
                            if (this.revert && !this.cancelRevert) {
                                this.setOffset(this.startOffset, true)
                            } else {
                                this.setDragging(false)
                            }
                            this.fireEvent("dragend", this, a)
                        }
                        return true
                    },
                    onOrientationChange : function() {
                        this.updateBoundary()
                    },
                    setDragging : function(a) {
                        if (a) {
                            if (!this.dragging) {
                                this.dragging = true;
                                this.getProxyEl().addCls(this.draggingCls)
                            }
                        } else {
                            if (this.dragging) {
                                this.dragging = false;
                                this.getProxyEl().removeCls(this.draggingCls)
                            }
                        }
                        return this
                    },
                    getProxyEl : function() {
                        return this.proxy || this.el
                    },
                    destroy : function() {
                        this.el.removeCls(this.baseCls);
                        this.getProxyEl().removeCls(this.proxyCls);
                        this.clearListeners();
                        this.disable()
                    },
                    reset : function() {
                        this.startOffset = new Ext.util.Offset(0, 0);
                        this.setOffset(this.startOffset);
                        var a = this.initialRegion.copy();
                        this.updateBoundary();
                        this.initialRegion = this.region = this.getProxyEl()
                                .getPageBox(true);
                        this.startTouchPoint.x += this.initialRegion.left
                                - a.left;
                        this.startTouchPoint.y += this.initialRegion.top
                                - a.top
                    },
                    moveTo : function(a, b) {
                        this.setOffset(new Ext.util.Offset(a
                                - this.initialRegion.left, b
                                - this.initialRegion.top));
                        return this
                    },
                    isDragging : function() {
                        return this.dragging
                    },
                    isVertical : function() {
                        return this.vertical
                    },
                    isHorizontal : function() {
                        return this.horizontal
                    }
                });
Ext.util.Draggable.Animation = {};
Ext.util.Draggable.Animation.Abstract = Ext.extend(Object, {
    startTime : null,
    startOffset : 0,
    constructor : function(a) {
        a = a || {};
        this.set(a);
        if (!this.startTime) {
            this.startTime = Date.now()
        }
    },
    set : function(a, b) {
        if (Ext.isObject(a)) {
            Ext.apply(this, a)
        } else {
            this[a] = b
        }
        return this
    },
    getOffset : Ext.emptyFn
});
Ext.util.Draggable.Animation.Linear = Ext.extend(
        Ext.util.Draggable.Animation.Abstract, {
            duration : 0,
            endOffset : 0,
            getOffset : function() {
                var c = this.endOffset - this.startOffset, a = Date.now()
                        - this.startTime, b = Math.min(1, (a / this.duration));
                return this.startOffset + (b * c)
            }
        });
Ext.util.Droppable = Ext.extend(Ext.util.Observable, {
    baseCls : "x-droppable",
    activeCls : "x-drop-active",
    invalidCls : "x-drop-invalid",
    hoverCls : "x-drop-hover",
    validDropMode : "intersect",
    disabled : false,
    group : "base",
    tolerance : null,
    monitoring : false,
    constructor : function(b, a) {
        a = a || {};
        Ext.apply(this, a);
        this.addEvents("dropactivate", "dropdeactivate", "dropenter",
                "dropleave", "drop");
        this.el = Ext.get(b);
        Ext.util.Droppable.superclass.constructor.call(this);
        if (!this.disabled) {
            this.enable()
        }
        this.el.addCls(this.baseCls)
    },
    onDragStart : function(a, b) {
        if (a.group === this.group) {
            this.monitoring = true;
            this.el.addCls(this.activeCls);
            this.region = this.el.getPageBox(true);
            a.on({
                drag : this.onDrag,
                beforedragend : this.onBeforeDragEnd,
                dragend : this.onDragEnd,
                scope : this
            });
            if (this.isDragOver(a)) {
                this.setCanDrop(true, a, b)
            }
            this.fireEvent("dropactivate", this, a, b)
        } else {
            a.on({
                dragend : function() {
                    this.el.removeCls(this.invalidCls)
                },
                scope : this,
                single : true
            });
            this.el.addCls(this.invalidCls)
        }
    },
    isDragOver : function(a, b) {
        return this.region[this.validDropMode](a.region)
    },
    onDrag : function(a, b) {
        this.setCanDrop(this.isDragOver(a), a, b)
    },
    setCanDrop : function(c, a, b) {
        if (c && !this.canDrop) {
            this.canDrop = true;
            this.el.addCls(this.hoverCls);
            this.fireEvent("dropenter", this, a, b)
        } else {
            if (!c && this.canDrop) {
                this.canDrop = false;
                this.el.removeCls(this.hoverCls);
                this.fireEvent("dropleave", this, a, b)
            }
        }
    },
    onBeforeDragEnd : function(a, b) {
        a.cancelRevert = this.canDrop
    },
    onDragEnd : function(a, b) {
        this.monitoring = false;
        this.el.removeCls(this.activeCls);
        a.un({
            drag : this.onDrag,
            beforedragend : this.onBeforeDragEnd,
            dragend : this.onDragEnd,
            scope : this
        });
        if (this.canDrop) {
            this.canDrop = false;
            this.el.removeCls(this.hoverCls);
            this.fireEvent("drop", this, a, b)
        }
        this.fireEvent("dropdeactivate", this, a, b)
    },
    enable : function() {
        if (!this.mgr) {
            this.mgr = Ext.util.Observable.observe(Ext.util.Draggable)
        }
        this.mgr.on({
            dragstart : this.onDragStart,
            scope : this
        });
        this.disabled = false
    },
    disable : function() {
        this.mgr.un({
            dragstart : this.onDragStart,
            scope : this
        });
        this.disabled = true
    },
    isDisabled : function() {
        return this.disabled
    },
    isMonitoring : function() {
        return this.monitoring
    }
});
(function() {
    Ext.ScrollManager = new Ext.AbstractManager();
    Ext.util.ScrollView = Ext
            .extend(
                    Ext.util.Observable,
                    {
                        useIndicators : true,
                        indicatorConfig : {},
                        indicatorMargin : 4,
                        constructor : function(b, a) {
                            var c = [], d = [ "vertical", "horizontal" ];
                            Ext.util.ScrollView.superclass.constructor
                                    .call(this);
                            [ "useIndicators", "indicatorConfig",
                                    "indicatorMargin" ].forEach(function(e) {
                                if (a.hasOwnProperty(e)) {
                                    this[e] = a[e];
                                    delete a[e]
                                }
                            }, this);
                            a.scrollView = this;
                            this.scroller = new Ext.util.Scroller(b, a);
                            if (this.useIndicators === true) {
                                d.forEach(function(e) {
                                    if (this.scroller[e]) {
                                        c.push(e)
                                    }
                                }, this)
                            } else {
                                if (d.indexOf(this.useIndicators) !== -1) {
                                    c.push(this.useIndicators)
                                }
                            }
                            this.indicators = {};
                            this.indicatorOffsetExtras = {};
                            c
                                    .forEach(
                                            function(e) {
                                                this.indicators[e] = new Ext.util.Scroller.Indicator(
                                                        this.scroller.container,
                                                        Ext
                                                                .apply(
                                                                        {},
                                                                        this.indicatorConfig,
                                                                        {
                                                                            type : e
                                                                        }))
                                            }, this);
                            this.mon(this.scroller, {
                                scrollstart : this.onScrollStart,
                                scrollend : this.onScrollEnd,
                                scroll : this.onScroll,
                                scope : this
                            })
                        },
                        onScrollStart : function() {
                            this.showIndicators()
                        },
                        onScrollEnd : function() {
                            this.hideIndicators()
                        },
                        onScroll : function(a) {
                            if (a.offsetBoundary == null
                                    || (!this.indicators.vertical && !this.indicators.horizontal)) {
                                return
                            }
                            var c, b, e, f = a.offsetBoundary, d = a.offset;
                            this.containerSize = a.containerBox;
                            this.scrollerSize = a.size;
                            this.outOfBoundOffset = f.getOutOfBoundOffset(d);
                            this.restrictedOffset = f.restrict(d);
                            this.boundarySize = f.getSize();
                            if (!this.indicatorSizes) {
                                this.indicatorSizes = {
                                    vertical : 0,
                                    horizontal : 0
                                }
                            }
                            if (!this.indicatorOffsets) {
                                this.indicatorOffsets = {
                                    vertical : 0,
                                    horizontal : 0
                                }
                            }
                            Ext
                                    .iterate(
                                            this.indicators,
                                            function(h, g) {
                                                c = (h == "vertical") ? "height"
                                                        : "width";
                                                b = (h == "vertical") ? "y"
                                                        : "x";
                                                e = (h == "vertical") ? "bottom"
                                                        : "right";
                                                if (this.scrollerSize[c] < this.containerSize[c]) {
                                                    this.indicatorSizes[h] = this.containerSize[c]
                                                            * (this.scrollerSize[c] / this.containerSize[c])
                                                } else {
                                                    this.indicatorSizes[h] = this.containerSize[c]
                                                            * (this.containerSize[c] / this.scrollerSize[c])
                                                }
                                                this.indicatorSizes[h] -= Math
                                                        .abs(this.outOfBoundOffset[b]);
                                                this.indicatorSizes[h] = Math
                                                        .max(
                                                                this.indicatorMargin * 4,
                                                                this.indicatorSizes[h]);
                                                if (this.boundarySize[c] != 0) {
                                                    this.indicatorOffsets[h] = (((f[e] - this.restrictedOffset[b]) / this.boundarySize[c]) * (this.containerSize[c] - this.indicatorSizes[h]))
                                                } else {
                                                    if (d[b] < f[e]) {
                                                        this.indicatorOffsets[h] = this.containerSize[c]
                                                                - this.indicatorSizes[h]
                                                    } else {
                                                        this.indicatorOffsets[h] = 0
                                                    }
                                                }
                                                g
                                                        .setOffset(this.indicatorOffsetExtras[h]
                                                                + this.indicatorOffsets[h]
                                                                + this.indicatorMargin);
                                                g
                                                        .setSize(this.indicatorSizes[h]
                                                                - (this.indicatorMargin * 2))
                                            }, this)
                        },
                        showIndicators : function() {
                            Ext
                                    .iterate(
                                            this.indicators,
                                            function(b, a) {
                                                a.show();
                                                this.indicatorOffsetExtras[b] = a.el.dom.parentNode[b === "vertical" ? "scrollTop"
                                                        : "scrollLeft"]
                                            }, this);
                            return this
                        },
                        hideIndicators : function() {
                            Ext.iterate(this.indicators, function(b, a) {
                                a.hide()
                            }, this)
                        },
                        destroy : function() {
                            this.scroller.destroy();
                            if (this.indicators) {
                                Ext.iterate(this.indicators, function(b, a) {
                                    a.destroy()
                                }, this)
                            }
                            return Ext.util.ScrollView.superclass.destroy
                                    .apply(this, arguments)
                        }
                    });
    Ext.util.Scroller = Ext
            .extend(
                    Ext.util.Draggable,
                    {
                        baseCls : "",
                        draggingCls : "",
                        direction : "both",
                        constrain : "parent",
                        outOfBoundRestrictFactor : 0.5,
                        acceleration : 20,
                        autoAdjustFps : false,
                        friction : 0.5,
                        startMomentumResetTime : 350,
                        springTension : 0.3,
                        minVelocityForAnimation : 1,
                        bounces : true,
                        momentum : true,
                        cancelRevert : true,
                        threshold : 5,
                        constructor : function(f, d) {
                            f = Ext.get(f);
                            var a = Ext.ScrollManager.get(f.id);
                            if (a) {
                                return Ext.apply(a, d)
                            }
                            Ext.util.Scroller.superclass.constructor.apply(
                                    this, arguments);
                            this.addEvents("scrollstart", "scroll",
                                    "scrollend", "bouncestart", "bounceend");
                            this.on({
                                dragstart : this.onDragStart,
                                offsetchange : this.onOffsetChange,
                                scope : this
                            });
                            Ext.ScrollManager.register(this);
                            this.el.addCls("x-scroller");
                            this.container.addCls("x-scroller-parent");
                            if (this.bounces !== false) {
                                var e = this.bounces === "both"
                                        || this.bounces === true, b = e
                                        || this.bounces === "horizontal", c = e
                                        || this.bounces === "vertical";
                                this.bounces = {
                                    x : b,
                                    y : c
                                }
                            }
                            this.theta = Math.log(1 - (this.friction / 10));
                            this.bouncingVelocityFactor = this.springTension
                                    * Math.E;
                            this.bouncingTimeFactor = ((1 / this.springTension) * this.acceleration);
                            if (!this.decelerationAnimation) {
                                this.decelerationAnimation = {}
                            }
                            if (!this.bouncingAnimation) {
                                this.bouncingAnimation = {}
                            }
                            [ "x", "y" ]
                                    .forEach(
                                            function(g) {
                                                if (!this.decelerationAnimation[g]) {
                                                    this.decelerationAnimation[g] = new Ext.util.Scroller.Animation.Deceleration(
                                                            {
                                                                acceleration : this.acceleration,
                                                                theta : this.theta
                                                            })
                                                }
                                                if (!this.bouncingAnimation[g]) {
                                                    this.bouncingAnimation[g] = new Ext.util.Scroller.Animation.Bouncing(
                                                            {
                                                                acceleration : this.acceleration,
                                                                springTension : this.springTension
                                                            })
                                                }
                                            }, this);
                            return this
                        },
                        updateBoundary : function(a) {
                            Ext.util.Scroller.superclass.updateBoundary.apply(
                                    this, arguments);
                            this.snapToBoundary(a);
                            return this
                        },
                        onOffsetChange : function(a, b) {
                            this.fireEvent("scroll", a, {
                                x : -b.x,
                                y : -b.y
                            })
                        },
                        onTouchStart : function(a) {
                            Ext.util.Scroller.superclass.onTouchStart.apply(
                                    this, arguments);
                            this.stopMomentumAnimation()
                        },
                        onDragStart : function(a) {
                            this.fireEvent("scrollstart", this, a)
                        },
                        setStartTime : function(a) {
                            this.startTime = a.time;
                            this.originalStartTime = (a.event.originalTimeStamp) ? a.event.originalTimeStamp
                                    : a.time
                        },
                        onStart : function(a) {
                            if (Ext.util.Scroller.superclass.onStart.apply(
                                    this, arguments) !== true) {
                                return
                            }
                            this.setStartTime(a);
                            this.lastEventTime = a.time;
                            this.startTimeOffset = this.offset.copy();
                            this.isScrolling = true;
                            this.momentumAnimationFramesHandled = 0
                        },
                        onDrag : function(a) {
                            if (Ext.util.Scroller.superclass.onDrag.apply(this,
                                    arguments) !== true) {
                                return
                            }
                            this.lastEventTime = a.time;
                            if (this.lastEventTime - this.startTime > this.startMomentumResetTime) {
                                this.setStartTime(a);
                                this.startTimeOffset = this.offset.copy()
                            }
                        },
                        onDragEnd : function(a) {
                            if (Ext.util.Scroller.superclass.onDragEnd.apply(
                                    this, arguments) !== true) {
                                return
                            }
                            if (!this.startMomentumAnimation(a)) {
                                this.fireScrollEndEvent()
                            }
                        },
                        onOrientationChange : function() {
                            Ext.util.Scroller.superclass.onOrientationChange
                                    .apply(this, arguments);
                            this.snapToBoundary()
                        },
                        fireScrollEndEvent : function() {
                            this.isScrolling = false;
                            this.isMomentumAnimating = false;
                            this.snapToBoundary();
                            this.fireEvent("scrollend", this, this.getOffset());
                            this.snapToSlot()
                        },
                        getLastActualFps : function() {
                            var a = (this.momentumAnimationEndTime
                                    - this.momentumAnimationStartTime - this.momentumAnimationProcessingTime) / 1000;
                            return this.momentumAnimationFramesHandled / a
                        },
                        scrollTo : function(c, a) {
                            this.stopMomentumAnimation();
                            var b = this.offsetBoundary
                                    .restrict(new Ext.util.Offset(-c.x, -c.y));
                            this.setOffset(b, a);
                            return this
                        },
                        scrollBy : function(b, a) {
                            this.stopMomentumAnimation();
                            var c = this.offset.copy();
                            c.x += b.x;
                            c.y += b.y;
                            this.setOffset(c, a);
                            return this
                        },
                        setSnap : function(a) {
                            this.snap = a
                        },
                        snapToBoundary : function(a) {
                            var b = this.offsetBoundary.restrict(this.offset);
                            this.setOffset(b, a);
                            return this
                        },
                        snapToSlot : function() {
                            var a = this.offsetBoundary.restrict(this.offset);
                            a.round();
                            if (this.snap) {
                                if (this.snap === true) {
                                    this.snap = {
                                        x : 50,
                                        y : 50
                                    }
                                } else {
                                    if (Ext.isNumber(this.snap)) {
                                        this.snap = {
                                            x : this.snap,
                                            y : this.snap
                                        }
                                    }
                                }
                                if (this.snap.y) {
                                    a.y = Math.round(a.y / this.snap.y)
                                            * this.snap.y
                                }
                                if (this.snap.x) {
                                    a.x = Math.round(a.x / this.snap.x)
                                            * this.snap.x
                                }
                                if (!this.offset.equals(a)) {
                                    this.scrollTo({
                                        x : -a.x,
                                        y : -a.y
                                    }, this.snapDuration)
                                }
                            }
                        },
                        startMomentumAnimation : function(g) {
                            var i = this, j = (g.event.originalTimeStamp) ? g.event.originalTimeStamp
                                    : g.time, c = Math.max(40, j
                                    - this.originalStartTime);
                            this.fireEvent("beforemomentumanimationstart");
                            if ((!this.momentum || !(c <= this.startMomentumResetTime))
                                    && !this.offsetBoundary
                                            .isOutOfBound(this.offset)) {
                                return false
                            }
                            var d = this.minVelocityForAnimation, f, h = this.offset
                                    .copy(), a, b = (c / this.acceleration);
                            this.isBouncing = {
                                x : false,
                                y : false
                            };
                            this.isDecelerating = {
                                x : false,
                                y : false
                            };
                            this.momentumAnimationStartTime = g.time;
                            this.momentumAnimationProcessingTime = 0;
                            this.bouncingData = {
                                x : null,
                                y : null
                            };
                            this.momentumAnimationStartVelocity = {
                                x : (this.offset.x - this.startTimeOffset.x)
                                        / b,
                                y : (this.offset.y - this.startTimeOffset.y)
                                        / b
                            };
                            this.momentumAnimationStartOffset = h;
                            [ "x", "y" ]
                                    .forEach(
                                            function(e) {
                                                this.isDecelerating[e] = (Math
                                                        .abs(this.momentumAnimationStartVelocity[e]) > d);
                                                if (this.bounces
                                                        && this.bounces[e]) {
                                                    a = this.offsetBoundary
                                                            .restrict(e, h[e]);
                                                    if (a !== h[e]) {
                                                        f = (h[e] - a)
                                                                * this.bouncingVelocityFactor;
                                                        this.bouncingData[e] = {
                                                            axis : e,
                                                            offset : a,
                                                            time : this.momentumAnimationStartTime,
                                                            velocity : f
                                                        };
                                                        this.isBouncing[e] = true;
                                                        this.isDecelerating[e] = false;
                                                        this
                                                                .fireEvent(
                                                                        "bouncestart",
                                                                        this,
                                                                        this.bouncingData[e]);
                                                        this.bouncingAnimation[e]
                                                                .set({
                                                                    startTime : this.bouncingData[e].time
                                                                            - this.bouncingTimeFactor,
                                                                    startOffset : this.bouncingData[e].offset,
                                                                    startVelocity : this.bouncingData[e].velocity
                                                                })
                                                    }
                                                }
                                                if (this.isDecelerating[e]) {
                                                    this.decelerationAnimation[e]
                                                            .set({
                                                                startVelocity : this.momentumAnimationStartVelocity[e],
                                                                startOffset : this.momentumAnimationStartOffset[e],
                                                                startTime : this.momentumAnimationStartTime
                                                            })
                                                }
                                            }, this);
                            if (this.isDecelerating.x || this.isDecelerating.y
                                    || this.isBouncing.x || this.isBouncing.y) {
                                this.isMomentumAnimating = true;
                                this.momentumAnimationFramesHandled = 0;
                                this.fireEvent("momentumanimationstart");
                                i.handleMomentumAnimationFrame();
                                this.momentumAnimationTimer = setInterval(
                                        function() {
                                            i.handleMomentumAnimationFrame()
                                        }, this.getFrameDuration());
                                return true
                            }
                            return false
                        },
                        stopMomentumAnimation : function() {
                            if (this.isMomentumAnimating) {
                                if (this.momentumAnimationTimer) {
                                    clearInterval(this.momentumAnimationTimer)
                                }
                                this.momentumAnimationEndTime = Date.now();
                                var a = this.getLastActualFps();
                                if (!this.maxFps || a > this.maxFps) {
                                    this.maxFps = a
                                }
                                if (this.autoAdjustFps) {
                                    this.fps = this.maxFps
                                }
                                this.isDecelerating = {};
                                this.isBouncing = {};
                                this.fireEvent("momentumanimationend");
                                this.fireScrollEndEvent()
                            }
                            return this
                        },
                        handleMomentumAnimationFrame : function() {
                            if (!this.isMomentumAnimating) {
                                return
                            }
                            var c = Date.now(), f = this.offset.copy(), e = this.offsetBoundary, b, a, d;
                            [ "x", "y" ]
                                    .forEach(
                                            function(g) {
                                                if (this.isDecelerating[g]) {
                                                    f[g] = this.decelerationAnimation[g]
                                                            .getOffset();
                                                    b = this.momentumAnimationStartVelocity[g]
                                                            * this.decelerationAnimation[g]
                                                                    .getFrictionFactor();
                                                    d = e.getOutOfBoundOffset(
                                                            g, f[g]);
                                                    if (d !== 0) {
                                                        a = e.restrict(g, f[g]);
                                                        if (this.bounces
                                                                && this.bounces[g]) {
                                                            this.bouncingData[g] = {
                                                                axis : g,
                                                                offset : a,
                                                                time : c,
                                                                velocity : b
                                                            };
                                                            this
                                                                    .fireEvent(
                                                                            "bouncestart",
                                                                            this,
                                                                            this.bouncingData[g]);
                                                            this.bouncingAnimation[g]
                                                                    .set({
                                                                        startTime : this.bouncingData[g].time,
                                                                        startOffset : this.bouncingData[g].offset,
                                                                        startVelocity : this.bouncingData[g].velocity
                                                                    });
                                                            this.isBouncing[g] = true
                                                        }
                                                        this.isDecelerating[g] = false
                                                    } else {
                                                        if (Math.abs(b) <= 1) {
                                                            this.isDecelerating[g] = false
                                                        }
                                                    }
                                                } else {
                                                    if (this.isBouncing[g]) {
                                                        f[g] = this.bouncingAnimation[g]
                                                                .getOffset();
                                                        a = e.restrict(g, f[g]);
                                                        if (Math.abs(f[g] - a) <= 1) {
                                                            this.isBouncing[g] = false;
                                                            this
                                                                    .fireEvent(
                                                                            "bounceend",
                                                                            this,
                                                                            {
                                                                                axis : g
                                                                            });
                                                            f[g] = a
                                                        }
                                                    }
                                                }
                                            }, this);
                            if (!this.isDecelerating.x
                                    && !this.isDecelerating.y
                                    && !this.isBouncing.x && !this.isBouncing.y) {
                                this.stopMomentumAnimation();
                                return
                            }
                            this.momentumAnimationFramesHandled++;
                            this.momentumAnimationProcessingTime += Date.now()
                                    - c;
                            this.setOffset(f)
                        },
                        destroy : function() {
                            Ext.ScrollManager.unregister(this);
                            return Ext.util.Scroller.superclass.destroy.apply(
                                    this, arguments)
                        }
                    });
    Ext.util.Scroller.Animation = {};
    Ext.util.Scroller.Animation.Deceleration = Ext.extend(
            Ext.util.Draggable.Animation.Abstract, {
                acceleration : 30,
                theta : null,
                startVelocity : null,
                getOffset : function() {
                    return this.startOffset - this.startVelocity
                            * (1 - this.getFrictionFactor()) / this.theta
                },
                getFrictionFactor : function() {
                    var a = Date.now() - this.startTime;
                    return Math.exp(a / this.acceleration * this.theta)
                }
            });
    Ext.util.Scroller.Animation.Bouncing = Ext
            .extend(
                    Ext.util.Draggable.Animation.Abstract,
                    {
                        springTension : 0.3,
                        acceleration : 30,
                        startVelocity : null,
                        getOffset : function() {
                            var b = (Date.now() - this.startTime), a = (b / this.acceleration)
                                    * Math.pow(Math.E, -this.springTension
                                            * (b / this.acceleration));
                            return this.startOffset + (this.startVelocity * a)
                        }
                    });
    Ext.util.Scroller.Indicator = Ext.extend(Object,
            {
                baseCls : "x-scrollbar",
                ui : "dark",
                type : "horizontal",
                constructor : function(a, b) {
                    this.container = a;
                    Ext.apply(this, b);
                    this.el = this.container.createChild({
                        cls : [ this.baseCls, this.baseCls + "-" + this.type,
                                this.baseCls + "-" + this.ui ].join(" ")
                    });
                    this.offset = new Ext.util.Offset();
                    this.hide()
                },
                hide : function() {
                    var a = this;
                    if (this.hideTimer) {
                        clearTimeout(this.hideTimer)
                    }
                    this.hideTimer = setTimeout(function() {
                        a.el.setStyle("opacity", 0)
                    }, 100);
                    return this
                },
                show : function() {
                    if (this.hideTimer) {
                        clearTimeout(this.hideTimer)
                    }
                    this.el.setStyle("opacity", 1);
                    return this
                },
                setVisibility : function(a) {
                    return this[a ? "show" : "hide"]()
                },
                setSize : function(a) {
                    if (this.size && a > this.size) {
                        a = Math.round(a)
                    }
                    this.el.dom.style[(this.type == "horizontal") ? "width"
                            : "height"] = a + "px";
                    this.size = a;
                    return this
                },
                setOffset : function(a) {
                    if (this.type == "vertical") {
                        this.offset.y = a
                    } else {
                        this.offset.x = a
                    }
                    if (!Ext.is.iOS && !Ext.is.Desktop) {
                        if (this.type == "vertical") {
                            this.el.dom.style.top = this.offset.y + "px"
                        } else {
                            this.el.dom.style.left = this.offset.x + "px"
                        }
                    } else {
                        Ext.Element.cssTranslate(this.el, this.offset)
                    }
                    return this
                }
            })
})();
Ext.util.Sortable = Ext
        .extend(
                Ext.util.Observable,
                {
                    baseCls : "x-sortable",
                    direction : "vertical",
                    cancelSelector : null,
                    constrain : window,
                    group : "base",
                    revert : true,
                    itemSelector : null,
                    handleSelector : null,
                    disabled : false,
                    delay : 0,
                    sorting : false,
                    vertical : false,
                    vertical : false,
                    constructor : function(b, a) {
                        a = a || {};
                        Ext.apply(this, a);
                        this.addEvents("sortstart", "sortend", "sortchange");
                        this.el = Ext.get(b);
                        Ext.util.Sortable.superclass.constructor.call(this);
                        if (this.direction == "horizontal") {
                            this.horizontal = true
                        } else {
                            if (this.direction == "vertical") {
                                this.vertical = true
                            } else {
                                this.horizontal = this.vertical = true
                            }
                        }
                        this.el.addCls(this.baseCls);
                        this.startEventName = (this.delay > 0) ? "taphold"
                                : "tapstart";
                        if (!this.disabled) {
                            this.enable()
                        }
                    },
                    onStart : function(b, a) {
                        if (this.cancelSelector
                                && b.getTarget(this.cancelSelector)) {
                            return
                        }
                        if (this.handleSelector
                                && !b.getTarget(this.handleSelector)) {
                            return
                        }
                        if (!this.sorting) {
                            this.onSortStart(b, a)
                        }
                    },
                    onSortStart : function(c, b) {
                        this.sorting = true;
                        var a = new Ext.util.Draggable(b, {
                            threshold : 0,
                            revert : this.revert,
                            direction : this.direction,
                            constrain : this.constrain === true ? this.el
                                    : this.constrain,
                            animationDuration : 100
                        });
                        a.on({
                            drag : this.onDrag,
                            dragend : this.onDragEnd,
                            scope : this
                        });
                        this.dragEl = b;
                        this.calculateBoxes();
                        if (!a.dragging) {
                            a.onStart(c)
                        }
                        this.fireEvent("sortstart", this, c)
                    },
                    calculateBoxes : function() {
                        this.items = [];
                        var b = this.el.select(this.itemSelector, false), f = b.length, a, e, c, d;
                        for (a = 0; a < f; a++) {
                            c = b[a];
                            if (c != this.dragEl) {
                                e = Ext.fly(c).getPageBox(true);
                                e.el = c;
                                this.items.push(e)
                            }
                        }
                    },
                    onDrag : function(l, c) {
                        var g = this.items, f = g.length, h = l.region, d = false, b, a, j, k;
                        for (b = 0; b < f; b++) {
                            k = g[b];
                            a = h.intersect(k);
                            if (a) {
                                if (this.vertical
                                        && Math.abs(a.top - a.bottom) > (h.bottom - h.top) / 2) {
                                    if (h.bottom > k.top && k.top > h.top) {
                                        l.el.insertAfter(k.el)
                                    } else {
                                        l.el.insertBefore(k.el)
                                    }
                                    d = true
                                } else {
                                    if (this.horizontal
                                            && Math.abs(a.left - a.right) > (h.right - h.left) / 2) {
                                        if (h.right > k.left && k.left > h.left) {
                                            l.el.insertAfter(k.el)
                                        } else {
                                            l.el.insertBefore(k.el)
                                        }
                                        d = true
                                    }
                                }
                                if (d) {
                                    l.reset();
                                    l.moveTo(h.left, h.top);
                                    this.calculateBoxes();
                                    this.fireEvent("sortchange", this, l.el,
                                            this.el.select(this.itemSelector,
                                                    false).indexOf(l.el.dom));
                                    return
                                }
                            }
                        }
                    },
                    onDragEnd : function(a, b) {
                        a.destroy();
                        this.sorting = false;
                        this.fireEvent("sortend", this, a, b)
                    },
                    enable : function() {
                        this.el.on(this.startEventName, this.onStart, this, {
                            delegate : this.itemSelector,
                            holdThreshold : this.delay
                        });
                        this.disabled = false
                    },
                    disable : function() {
                        this.el.un(this.startEventName, this.onStart, this);
                        this.disabled = true
                    },
                    isDisabled : function() {
                        return this.disabled
                    },
                    isSorting : function() {
                        return this.sorting
                    },
                    isVertical : function() {
                        return this.vertical
                    },
                    isHorizontal : function() {
                        return this.horizontal
                    }
                });
(function() {
    Date.useStrict = false;
    function b(d) {
        var c = Array.prototype.slice.call(arguments, 1);
        return d.replace(/\{(\d+)\}/g, function(e, f) {
            return c[f]
        })
    }
    Date.formatCodeToRegex = function(d, c) {
        var e = Date.parseCodes[d];
        if (e) {
            e = typeof e == "function" ? e() : e;
            Date.parseCodes[d] = e
        }
        return e ? Ext.applyIf({
            c : e.c ? b(e.c, c || "{0}") : e.c
        }, e) : {
            g : 0,
            c : null,
            s : Ext.util.Format.escapeRegex(d)
        }
    };
    var a = Date.formatCodeToRegex;
    Ext
            .apply(
                    Date,
                    {
                        parseFunctions : {
                            "M$" : function(d, c) {
                                var e = new RegExp(
                                        "\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/");
                                var f = (d || "").match(e);
                                return f ? new Date(((f[1] || "") + f[2]) * 1)
                                        : null
                            }
                        },
                        parseRegexes : [],
                        formatFunctions : {
                            "M$" : function() {
                                return "\\/Date(" + this.getTime() + ")\\/"
                            }
                        },
                        y2kYear : 50,
                        MILLI : "ms",
                        SECOND : "s",
                        MINUTE : "mi",
                        HOUR : "h",
                        DAY : "d",
                        MONTH : "mo",
                        YEAR : "y",
                        defaults : {},
                        dayNames : [ "Sunday", "Monday", "Tuesday",
                                "Wednesday", "Thursday", "Friday", "Saturday" ],
                        monthNames : [ "January", "February", "March", "April",
                                "May", "June", "July", "August", "September",
                                "October", "November", "December" ],
                        monthNumbers : {
                            Jan : 0,
                            Feb : 1,
                            Mar : 2,
                            Apr : 3,
                            May : 4,
                            Jun : 5,
                            Jul : 6,
                            Aug : 7,
                            Sep : 8,
                            Oct : 9,
                            Nov : 10,
                            Dec : 11
                        },
                        getShortMonthName : function(c) {
                            return Date.monthNames[c].substring(0, 3)
                        },
                        getShortDayName : function(c) {
                            return Date.dayNames[c].substring(0, 3)
                        },
                        getMonthNumber : function(c) {
                            return Date.monthNumbers[c.substring(0, 1)
                                    .toUpperCase()
                                    + c.substring(1, 3).toLowerCase()]
                        },
                        formatCodes : {
                            d : "Ext.util.Format.leftPad(this.getDate(), 2, '0')",
                            D : "Date.getShortDayName(this.getDay())",
                            j : "this.getDate()",
                            l : "Date.dayNames[this.getDay()]",
                            N : "(this.getDay() ? this.getDay() : 7)",
                            S : "this.getSuffix()",
                            w : "this.getDay()",
                            z : "this.getDayOfYear()",
                            W : "Ext.util.Format.leftPad(this.getWeekOfYear(), 2, '0')",
                            F : "Date.monthNames[this.getMonth()]",
                            m : "Ext.util.Format.leftPad(this.getMonth() + 1, 2, '0')",
                            M : "Date.getShortMonthName(this.getMonth())",
                            n : "(this.getMonth() + 1)",
                            t : "this.getDaysInMonth()",
                            L : "(this.isLeapYear() ? 1 : 0)",
                            o : "(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))",
                            Y : "this.getFullYear()",
                            y : "('' + this.getFullYear()).substring(2, 4)",
                            a : "(this.getHours() < 12 ? 'am' : 'pm')",
                            A : "(this.getHours() < 12 ? 'AM' : 'PM')",
                            g : "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
                            G : "this.getHours()",
                            h : "Ext.util.Format.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
                            H : "Ext.util.Format.leftPad(this.getHours(), 2, '0')",
                            i : "Ext.util.Format.leftPad(this.getMinutes(), 2, '0')",
                            s : "Ext.util.Format.leftPad(this.getSeconds(), 2, '0')",
                            u : "Ext.util.Format.leftPad(this.getMilliseconds(), 3, '0')",
                            O : "this.getGMTOffset()",
                            P : "this.getGMTOffset(true)",
                            T : "this.getTimezone()",
                            Z : "(this.getTimezoneOffset() * -60)",
                            c : function() {
                                for ( var j = "Y-m-dTH:i:sP", g = [], f = 0, d = j.length; f < d; ++f) {
                                    var h = j.charAt(f);
                                    g.push(h == "T" ? "'T'" : Date
                                            .getFormatCode(h))
                                }
                                return g.join(" + ")
                            },
                            U : "Math.round(this.getTime() / 1000)"
                        },
                        isValid : function(n, c, l, j, f, g, e) {
                            j = j || 0;
                            f = f || 0;
                            g = g || 0;
                            e = e || 0;
                            var k = new Date(n, c - 1, l, j, f, g, e);
                            return n == k.getFullYear()
                                    && c == k.getMonth() + 1
                                    && l == k.getDate() && j == k.getHours()
                                    && f == k.getMinutes()
                                    && g == k.getSeconds()
                                    && e == k.getMilliseconds()
                        },
                        parseDate : function(d, f, c) {
                            var e = Date.parseFunctions;
                            if (e[f] == null) {
                                Date.createParser(f)
                            }
                            return e[f](d, Ext.isDefined(c) ? c
                                    : Date.useStrict)
                        },
                        getFormatCode : function(d) {
                            var c = Date.formatCodes[d];
                            if (c) {
                                c = typeof c == "function" ? c() : c;
                                Date.formatCodes[d] = c
                            }
                            return c || ("'" + Ext.util.Format.escape(d) + "'")
                        },
                        createFormat : function(g) {
                            var f = [], c = false, e = "";
                            for ( var d = 0; d < g.length; ++d) {
                                e = g.charAt(d);
                                if (!c && e == "\\") {
                                    c = true
                                } else {
                                    if (c) {
                                        c = false;
                                        f.push("'" + Ext.util.Format.escape(e)
                                                + "'")
                                    } else {
                                        f.push(Date.getFormatCode(e))
                                    }
                                }
                            }
                            Date.formatFunctions[g] = new Function("return "
                                    + f.join("+"))
                        },
                        createParser : function() {
                            var c = [
                                    "var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,",
                                    "def = Date.defaults,",
                                    "results = String(input).match(Date.parseRegexes[{0}]);",
                                    "if(results){",
                                    "{1}",
                                    "if(u != null){",
                                    "v = new Date(u * 1000);",
                                    "}else{",
                                    "dt = (new Date()).clearTime();",
                                    "y = Ext.num(y, Ext.num(def.y, dt.getFullYear()));",
                                    "m = Ext.num(m, Ext.num(def.m - 1, dt.getMonth()));",
                                    "d = Ext.num(d, Ext.num(def.d, dt.getDate()));",
                                    "h  = Ext.num(h, Ext.num(def.h, dt.getHours()));",
                                    "i  = Ext.num(i, Ext.num(def.i, dt.getMinutes()));",
                                    "s  = Ext.num(s, Ext.num(def.s, dt.getSeconds()));",
                                    "ms = Ext.num(ms, Ext.num(def.ms, dt.getMilliseconds()));",
                                    "if(z >= 0 && y >= 0){",
                                    "v = new Date(y, 0, 1, h, i, s, ms);",
                                    "v = !strict? v : (strict === true && (z <= 364 || (v.isLeapYear() && z <= 365))? v.add(Date.DAY, z) : null);",
                                    "}else if(strict === true && !Date.isValid(y, m + 1, d, h, i, s, ms)){",
                                    "v = null;",
                                    "}else{",
                                    "v = new Date(y, m, d, h, i, s, ms);",
                                    "}",
                                    "}",
                                    "}",
                                    "if(v){",
                                    "if(zz != null){",
                                    "v = v.add(Date.SECOND, -v.getTimezoneOffset() * 60 - zz);",
                                    "}else if(o){",
                                    "v = v.add(Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
                                    "}", "}", "return v;" ].join("\n");
                            return function(l) {
                                var e = Date.parseRegexes.length, n = 1, f = [], k = [], j = false, d = "", h = 0, g, m;
                                for (; h < l.length; ++h) {
                                    d = l.charAt(h);
                                    if (!j && d == "\\") {
                                        j = true
                                    } else {
                                        if (j) {
                                            j = false;
                                            k.push(Ext.util.Format.escape(d))
                                        } else {
                                            g = a(d, n);
                                            n += g.g;
                                            k.push(g.s);
                                            if (g.g && g.c) {
                                                if (g.last) {
                                                    m = g
                                                } else {
                                                    f.push(g.c)
                                                }
                                            }
                                        }
                                    }
                                }
                                if (m) {
                                    f.push(m)
                                }
                                Date.parseRegexes[e] = new RegExp("^"
                                        + k.join("") + "$");
                                Date.parseFunctions[l] = new Function("input",
                                        "strict", b(c, e, f.join("")))
                            }
                        }(),
                        parseCodes : {
                            d : {
                                g : 1,
                                c : "d = parseInt(results[{0}], 10);\n",
                                s : "(\\d{2})"
                            },
                            j : {
                                g : 1,
                                c : "d = parseInt(results[{0}], 10);\n",
                                s : "(\\d{1,2})"
                            },
                            D : function() {
                                for ( var c = [], d = 0; d < 7; c.push(Date
                                        .getShortDayName(d)), ++d) {
                                }
                                return {
                                    g : 0,
                                    c : null,
                                    s : "(?:" + c.join("|") + ")"
                                }
                            },
                            l : function() {
                                return {
                                    g : 0,
                                    c : null,
                                    s : "(?:" + Date.dayNames.join("|") + ")"
                                }
                            },
                            N : {
                                g : 0,
                                c : null,
                                s : "[1-7]"
                            },
                            S : {
                                g : 0,
                                c : null,
                                s : "(?:st|nd|rd|th)"
                            },
                            w : {
                                g : 0,
                                c : null,
                                s : "[0-6]"
                            },
                            z : {
                                g : 1,
                                c : "z = parseInt(results[{0}], 10);\n",
                                s : "(\\d{1,3})"
                            },
                            W : {
                                g : 0,
                                c : null,
                                s : "(?:\\d{2})"
                            },
                            F : function() {
                                return {
                                    g : 1,
                                    c : "m = parseInt(Date.getMonthNumber(results[{0}]), 10);\n",
                                    s : "(" + Date.monthNames.join("|") + ")"
                                }
                            },
                            M : function() {
                                for ( var c = [], d = 0; d < 12; c.push(Date
                                        .getShortMonthName(d)), ++d) {
                                }
                                return Ext.applyIf({
                                    s : "(" + c.join("|") + ")"
                                }, a("F"))
                            },
                            m : {
                                g : 1,
                                c : "m = parseInt(results[{0}], 10) - 1;\n",
                                s : "(\\d{2})"
                            },
                            n : {
                                g : 1,
                                c : "m = parseInt(results[{0}], 10) - 1;\n",
                                s : "(\\d{1,2})"
                            },
                            t : {
                                g : 0,
                                c : null,
                                s : "(?:\\d{2})"
                            },
                            L : {
                                g : 0,
                                c : null,
                                s : "(?:1|0)"
                            },
                            o : function() {
                                return a("Y")
                            },
                            Y : {
                                g : 1,
                                c : "y = parseInt(results[{0}], 10);\n",
                                s : "(\\d{4})"
                            },
                            y : {
                                g : 1,
                                c : "var ty = parseInt(results[{0}], 10);\ny = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n",
                                s : "(\\d{1,2})"
                            },
                            a : function() {
                                return a("A")
                            },
                            A : {
                                calcLast : true,
                                g : 1,
                                c : "if (results[{0}] == 'AM') {\nif (!h || h == 12) { h = 0; }\n} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
                                s : "(AM|PM)"
                            },
                            g : function() {
                                return a("G")
                            },
                            G : {
                                g : 1,
                                c : "h = parseInt(results[{0}], 10);\n",
                                s : "(\\d{1,2})"
                            },
                            h : function() {
                                return a("H")
                            },
                            H : {
                                g : 1,
                                c : "h = parseInt(results[{0}], 10);\n",
                                s : "(\\d{2})"
                            },
                            i : {
                                g : 1,
                                c : "i = parseInt(results[{0}], 10);\n",
                                s : "(\\d{2})"
                            },
                            s : {
                                g : 1,
                                c : "s = parseInt(results[{0}], 10);\n",
                                s : "(\\d{2})"
                            },
                            u : {
                                g : 1,
                                c : "ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",
                                s : "(\\d+)"
                            },
                            O : {
                                g : 1,
                                c : [
                                        "o = results[{0}];",
                                        "var sn = o.substring(0,1),",
                                        "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),",
                                        "mn = o.substring(3,5) % 60;",
                                        "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.util.Format.leftPad(hr, 2, '0') + Ext.util.Format.leftPad(mn, 2, '0')) : null;\n" ]
                                        .join("\n"),
                                s : "([+-]\\d{4})"
                            },
                            P : {
                                g : 1,
                                c : [
                                        "o = results[{0}];",
                                        "var sn = o.substring(0,1),",
                                        "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),",
                                        "mn = o.substring(4,6) % 60;",
                                        "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.util.Format.leftPad(hr, 2, '0') + Ext.util.Format.leftPad(mn, 2, '0')) : null;\n" ]
                                        .join("\n"),
                                s : "([+-]\\d{2}:\\d{2})"
                            },
                            T : {
                                g : 0,
                                c : null,
                                s : "[A-Z]{1,4}"
                            },
                            Z : {
                                g : 1,
                                c : "zz = results[{0}] * 1;\nzz = (-43200 <= zz && zz <= 50400)? zz : null;\n",
                                s : "([+-]?\\d{1,5})"
                            },
                            c : function() {
                                var e = [], c = [
                                        a("Y", 1),
                                        a("m", 2),
                                        a("d", 3),
                                        a("h", 4),
                                        a("i", 5),
                                        a("s", 6),
                                        {
                                            c : "ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"
                                        },
                                        {
                                            c : [
                                                    "if(results[8]) {",
                                                    "if(results[8] == 'Z'){",
                                                    "zz = 0;",
                                                    "}else if (results[8].indexOf(':') > -1){",
                                                    a("P", 8).c, "}else{",
                                                    a("O", 8).c, "}", "}" ]
                                                    .join("\n")
                                        } ];
                                for ( var f = 0, d = c.length; f < d; ++f) {
                                    e.push(c[f].c)
                                }
                                return {
                                    g : 1,
                                    c : e.join(""),
                                    s : [ c[0].s, "(?:", "-", c[1].s, "(?:",
                                            "-", c[2].s, "(?:", "(?:T| )?",
                                            c[3].s, ":", c[4].s, "(?::",
                                            c[5].s, ")?",
                                            "(?:(?:\\.|,)(\\d+))?",
                                            "(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?",
                                            ")?", ")?", ")?" ].join("")
                                }
                            },
                            U : {
                                g : 1,
                                c : "u = parseInt(results[{0}], 10);\n",
                                s : "(-?\\d+)"
                            }
                        }
                    })
}());
Ext
        .apply(
                Date.prototype,
                {
                    dateFormat : function(a) {
                        if (Date.formatFunctions[a] == null) {
                            Date.createFormat(a)
                        }
                        return Date.formatFunctions[a].call(this)
                    },
                    getTimezone : function() {
                        return this
                                .toString()
                                .replace(
                                        /^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/,
                                        "$1$2").replace(/[^A-Z]/g, "")
                    },
                    getGMTOffset : function(a) {
                        return (this.getTimezoneOffset() > 0 ? "-" : "+")
                                + Ext.util.Format.leftPad(Math.floor(Math
                                        .abs(this.getTimezoneOffset()) / 60),
                                        2, "0")
                                + (a ? ":" : "")
                                + Ext.util.Format.leftPad(Math.abs(this
                                        .getTimezoneOffset() % 60), 2, "0")
                    },
                    getDayOfYear : function() {
                        var b = 0, e = this.clone(), a = this.getMonth(), c;
                        for (c = 0, e.setDate(1), e.setMonth(0); c < a; e
                                .setMonth(++c)) {
                            b += e.getDaysInMonth()
                        }
                        return b + this.getDate() - 1
                    },
                    getWeekOfYear : function() {
                        var a = 86400000, b = 7 * a;
                        return function() {
                            var d = Date.UTC(this.getFullYear(), this
                                    .getMonth(), this.getDate() + 3)
                                    / a, c = Math.floor(d / 7), e = new Date(c
                                    * b).getUTCFullYear();
                            return c - Math.floor(Date.UTC(e, 0, 7) / b) + 1
                        }
                    }(),
                    isLeapYear : function() {
                        var a = this.getFullYear();
                        return !!((a & 3) == 0 && (a % 100 || (a % 400 == 0 && a)))
                    },
                    getFirstDayOfMonth : function() {
                        var a = (this.getDay() - (this.getDate() - 1)) % 7;
                        return (a < 0) ? (a + 7) : a
                    },
                    getLastDayOfMonth : function() {
                        return this.getLastDateOfMonth().getDay()
                    },
                    getFirstDateOfMonth : function() {
                        return new Date(this.getFullYear(), this.getMonth(), 1)
                    },
                    getLastDateOfMonth : function() {
                        return new Date(this.getFullYear(), this.getMonth(),
                                this.getDaysInMonth())
                    },
                    getDaysInMonth : function() {
                        var a = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,
                                31 ];
                        return function() {
                            var b = this.getMonth();
                            return b == 1 && this.isLeapYear() ? 29 : a[b]
                        }
                    }(),
                    getSuffix : function() {
                        switch (this.getDate()) {
                        case 1:
                        case 21:
                        case 31:
                            return "st";
                        case 2:
                        case 22:
                            return "nd";
                        case 3:
                        case 23:
                            return "rd";
                        default:
                            return "th"
                        }
                    },
                    clone : function() {
                        return new Date(this.getTime())
                    },
                    isDST : function() {
                        return new Date(this.getFullYear(), 0, 1)
                                .getTimezoneOffset() != this
                                .getTimezoneOffset()
                    },
                    clearTime : function(f) {
                        if (f) {
                            return this.clone().clearTime()
                        }
                        var b = this.getDate();
                        this.setHours(0);
                        this.setMinutes(0);
                        this.setSeconds(0);
                        this.setMilliseconds(0);
                        if (this.getDate() != b) {
                            for ( var a = 1, e = this.add(Date.HOUR, a); e
                                    .getDate() != b; a++, e = this.add(
                                    Date.HOUR, a)) {
                            }
                            this.setDate(b);
                            this.setHours(e.getHours())
                        }
                        return this
                    },
                    add : function(b, c) {
                        var e = this.clone();
                        if (!b || c === 0) {
                            return e
                        }
                        switch (b.toLowerCase()) {
                        case Date.MILLI:
                            e.setMilliseconds(this.getMilliseconds() + c);
                            break;
                        case Date.SECOND:
                            e.setSeconds(this.getSeconds() + c);
                            break;
                        case Date.MINUTE:
                            e.setMinutes(this.getMinutes() + c);
                            break;
                        case Date.HOUR:
                            e.setHours(this.getHours() + c);
                            break;
                        case Date.DAY:
                            e.setDate(this.getDate() + c);
                            break;
                        case Date.MONTH:
                            var a = this.getDate();
                            if (a > 28) {
                                a = Math
                                        .min(a, this.getFirstDateOfMonth().add(
                                                "mo", c).getLastDateOfMonth()
                                                .getDate())
                            }
                            e.setDate(a);
                            e.setMonth(this.getMonth() + c);
                            break;
                        case Date.YEAR:
                            e.setFullYear(this.getFullYear() + c);
                            break
                        }
                        return e
                    },
                    between : function(c, a) {
                        var b = this.getTime();
                        return c.getTime() <= b && b <= a.getTime()
                    }
                });
Date.prototype.format = Date.prototype.dateFormat;
Ext.data.Connection = Ext
        .extend(
                Ext.util.Observable,
                {
                    method : "post",
                    url : null,
                    disableCaching : true,
                    disableCachingParam : "_dc",
                    timeout : 30000,
                    useDefaultHeader : true,
                    defaultPostHeader : "application/x-www-form-urlencoded; charset=UTF-8",
                    useDefaultXhrHeader : true,
                    defaultXhrHeader : "XMLHttpRequest",
                    constructor : function(a) {
                        a = a || {};
                        Ext.apply(this, a);
                        this.addEvents("beforerequest", "requestcomplete",
                                "requestexception");
                        this.requests = {};
                        Ext.data.Connection.superclass.constructor.call(this)
                    },
                    request : function(d) {
                        var m = this;
                        if (m.fireEvent("beforerequest", m, d) !== false) {
                            var h = d.params, c = d.url || m.url, f = d.urlParams, l = m.extraParams, i, j, g, b, q, s;
                            if (Ext.isFunction(h)) {
                                h = h.call(d.scope || window, d)
                            }
                            if (Ext.isFunction(c)) {
                                c = c.call(d.scope || window, d)
                            }
                            j = d.rawData || d.xmlData || d.jsonData || null;
                            if (d.jsonData && !Ext.isPrimitive(d.jsonData)) {
                                j = Ext.encode(j)
                            }
                            h = Ext.urlEncode(l, Ext.isObject(h) ? Ext
                                    .urlEncode(h) : h);
                            f = Ext.isObject(f) ? Ext.urlEncode(f) : f;
                            b = (d.method || ((h || j) ? "POST" : "GET"))
                                    .toUpperCase();
                            if (b === "GET" && d.disableCaching !== false
                                    && m.disableCaching) {
                                c = Ext.urlAppend(c, d.disableCachingParam
                                        || m.disableCachingParam + "="
                                        + (new Date().getTime()))
                            }
                            if ((b == "GET" || j) && h) {
                                c = Ext.urlAppend(c, h);
                                h = null
                            }
                            if (f) {
                                c = Ext.urlAppend(c, f)
                            }
                            if (d.autoAbort === true || m.autoAbort) {
                                m.abort()
                            }
                            s = this.getXhrInstance();
                            s.open(b.toUpperCase(), c, true);
                            g = Ext.apply({}, d.headers || {}, m.defaultHeaders
                                    || {});
                            if (!g["Content-Type"] && (j || h)) {
                                var p = m.defaultPostHeader, n = d.jsonData, a = d.xmlData;
                                if (j) {
                                    if (d.rawData) {
                                        p = "text/plain"
                                    } else {
                                        if (a && Ext.isDefined(a)) {
                                            p = "text/xml"
                                        } else {
                                            if (n && Ext.isDefined(n)) {
                                                p = "application/json"
                                            }
                                        }
                                    }
                                }
                                g["Content-Type"] = p
                            }
                            if (m.useDefaultXhrHeader && !g["X-Requested-With"]) {
                                g["X-Requested-With"] = m.defaultXhrHeader
                            }
                            for (q in g) {
                                if (g.hasOwnProperty(q)) {
                                    try {
                                        s.setRequestHeader(q, g[q])
                                    } catch (k) {
                                        m.fireEvent("exception", q, g[q])
                                    }
                                }
                            }
                            i = {
                                id : ++Ext.data.Connection.requestId,
                                xhr : s,
                                headers : g,
                                options : d,
                                timeout : setTimeout(function() {
                                    i.timedout = true;
                                    m.abort(i)
                                }, d.timeout || m.timeout)
                            };
                            m.requests[i.id] = i;
                            s.onreadystatechange = Ext.createDelegate(
                                    m.onStateChange, m, [ i ]);
                            s.send(j || h || null);
                            return i
                        } else {
                            return d.callback ? d.callback.apply(d.scope, [ d,
                                    undefined, undefined ]) : null
                        }
                    },
                    getXhrInstance : function() {
                        return new XMLHttpRequest()
                    },
                    isLoading : function(a) {
                        return a && !{
                            0 : true,
                            4 : true
                        }[a.xhr.readyState]
                    },
                    abort : function(a) {
                        if (a && this.isLoading(a)) {
                            if (!a.timedout) {
                                a.aborted = true
                            }
                            a.xhr.abort()
                        } else {
                            if (!a) {
                                var b;
                                for (b in this.requests) {
                                    if (!this.requests.hasOwnProperty(b)) {
                                        continue
                                    }
                                    this.abort(this.requests[b])
                                }
                            }
                        }
                    },
                    onStateChange : function(a) {
                        if (a.xhr.readyState == 4) {
                            clearTimeout(a.timeout);
                            delete a.timeout;
                            this.onComplete(a)
                        }
                    },
                    onComplete : function(d) {
                        var a = d.xhr.status, c = d.options, e = true, b;
                        if ((a >= 200 && a < 300) || a == 304) {
                            b = this.createResponse(d);
                            this.fireEvent("requestcomplete", this, b, c);
                            if (c.success) {
                                if (!c.scope) {
                                    c.success(b, c)
                                } else {
                                    c.success.call(c.scope, b, c)
                                }
                            }
                        } else {
                            e = false;
                            switch (a) {
                            case 12002:
                            case 12029:
                            case 12030:
                            case 12031:
                            case 12152:
                            case 13030:
                                b = this.createException(d);
                                break;
                            default:
                                b = this.createResponse(d)
                            }
                            this.fireEvent("requestexception", this, b, c);
                            if (c.failure) {
                                if (!c.scope) {
                                    c.failure(b, c)
                                } else {
                                    c.failure.call(c.scope, b, c)
                                }
                            }
                        }
                        if (c.callback) {
                            if (!c.scope) {
                                c.callback(c, e, b)
                            } else {
                                c.callback.call(c.scope, c, e, b)
                            }
                        }
                        delete this.requests[d.id]
                    },
                    createResponse : function(a) {
                        var g = a.xhr, b = {}, h = g.getAllResponseHeaders()
                                .replace(/\r\n/g, "\n").split("\n"), c = h.length, i, d, f, e;
                        while (c--) {
                            i = h[c];
                            d = i.indexOf(":");
                            if (d >= 0) {
                                f = i.substr(0, d).toLowerCase();
                                if (i.charAt(d + 1) == " ") {
                                    ++d
                                }
                                b[f] = i.substr(d + 1)
                            }
                        }
                        delete a.xhr;
                        return {
                            request : a,
                            requestId : a.id,
                            status : g.status,
                            statusText : g.statusText,
                            getResponseHeader : function(j) {
                                return b[j.toLowerCase()]
                            },
                            getAllResponseHeaders : function() {
                                return b
                            },
                            responseText : g.responseText,
                            responseXML : g.responseXML
                        }
                    },
                    createException : function(a) {
                        return {
                            request : a,
                            requestId : a.id,
                            status : a.aborted ? -1 : 0,
                            statusText : a.aborted ? "transaction aborted"
                                    : "communication failure",
                            aborted : a.aborted,
                            timedout : a.timedout
                        }
                    }
                });
Ext.data.Connection.requestId = 0;
Ext.Ajax = new Ext.data.Connection({
    autoAbort : false
});
Ext.util.EventSimulator = Ext.extend(Object, {
    supportedEvents : {
        touch : [ "touchstart", "touchmove", "touchend", "gesturestart",
                "gesturechange", "gestureend" ],
        mouse : [ "mousedown", "mousemove", "mouseup", "click" ]
    },
    getEventTypeByName : function(b) {
        var a = null;
        Ext.iterate(this.supportedEvents, function(d, c) {
            if (c.indexOf(b) != -1) {
                a = d
            }
        });
        return a
    },
    fire : function(b, c, a) {
        b = b.toLowerCase();
        if (arguments.length == 2) {
            a = c;
            c = document
        }
        switch (this.getEventTypeByName(b)) {
        case "touch":
            this.fireTouchEvent.call(this, b, c, a);
            break;
        case "mouse":
            this.fireMouseEvent.call(this, b, c, a);
            break;
        default:
            throw new Error("Event type " + b + " is currently not supported")
        }
        return this
    },
    createEvent : function(b, a) {
    },
    createEventData : function(b, a) {
        switch (this.getEventTypeByName(b.type)) {
        case "touch":
            return this.createTouchEventData(b.type, b.target, b, a);
            break;
        case "mouse":
            return this.createMouseEventData(b.type, b.target, b, a);
            break;
        default:
            throw new Error("Event type " + b.type
                    + " is currently not supported")
        }
    },
    fireTouchEvent : function(c, d, b) {
        var e = this.createTouchEventData(c, d, b);
        var a = this.createTouchEvent(c, e);
        a.isSimulated = true;
        return d.dispatchEvent(a)
    },
    createTouchEventData : function(c, d, a, b) {
        var e = {
            type : c,
            timeStamp : Date.now(),
            bubbles : true,
            cancelable : true,
            detail : 1,
            screenX : 0,
            screenY : 0,
            pageX : 0,
            pageY : 0,
            clientX : 0,
            clientY : 0,
            ctrlKey : false,
            altKey : false,
            shiftKey : false,
            metaKey : false,
            scale : 1,
            rotation : 0
        };
        if (!b) {
            e.target = d;
            e.view = document.defaultView
        }
        if (a) {
            Ext.iterate(e, function(f, g) {
                if (a.hasOwnProperty(f)) {
                    e[f] = a[f]
                }
            })
        }
        [ "touches", "targetTouches", "changedTouches" ].forEach(function(f) {
            if (a.hasOwnProperty(f)) {
                e[f] = this.createTouchList(a[f], d, b)
            } else {
                e[f] = this.createTouchList(e, d, b)
            }
        }, this);
        return e
    },
    createTouchEvent : function(b, c) {
        if (typeof b != "string") {
            c = b;
            b = b.type
        }
        var a = document.createEvent("TouchEvent");
        if (a.initTouchEvent.length == 9) {
            a.initTouchEvent(c.touches, c.targetTouches, c.changedTouches, b,
                    c.view, c.screenX, c.screenY, c.clientX, c.clientY)
        } else {
            a.initTouchEvent(b, c.bubbles, c.cancelable, c.view, c.detail,
                    c.screenX, c.screenY, c.pageX, c.pageY, c.ctrlKey,
                    c.altKey, c.shiftKey, c.metaKey, c.touches,
                    c.targetTouches, c.changedTouches, c.scale, c.rotation)
        }
        return a
    },
    createTouch : function(c, a, b) {
        if (!document.createTouch || b) {
            return {
                pageX : a.pageX,
                pageY : a.pageY,
                clientX : a.pageX,
                clientY : a.pageY,
                screenX : a.pageX,
                screenY : a.pageY,
                identifier : +a.identifier || 0
            }
        }
        return document.createTouch(document.defaultView, c,
                +a.identifier || 0, +a.pageX || 0, +a.pageY || 0,
                +a.screenX || 0, +a.screenY || 0)
    },
    createTouchList : function(c, e, b) {
        var f, d = [];
        if (Ext.isObject(c) && typeof c.target != "undefined") {
            c = [ c ]
        }
        if (c) {
            for ( var a = 0; a < c.length; a++) {
                if (!b && !c[a].target) {
                    c[a].target = e
                }
                f = this.createTouch(c[a].target, c[a], b);
                d.push(f)
            }
        }
        if (!document.createTouchList || b) {
            return d
        }
        return document.createTouchList.apply(document, d)
    },
    fireMouseEvent : function(b, e, a) {
        var d = this.createMouseEventData(b, e, a);
        var c = this.createMouseEvent(b, d);
        c.isSimulated = true;
        c.originalTimeStamp = d.timeStamp;
        return e.dispatchEvent(c)
    },
    createMouseEventData : function(c, g, a, b) {
        var f = {
            type : c,
            timeStamp : Date.now(),
            bubbles : true,
            cancelable : (c != "mousemove"),
            detail : 1,
            screenX : 0,
            screenY : 0,
            pageX : 0,
            pageY : 0,
            clientX : 0,
            clientY : 0,
            ctrlKey : false,
            altKey : false,
            shiftKey : false,
            metaKey : false,
            button : 0,
            relatedTarget : null
        }, e = [ "screen", "client", "page" ], d = {
            x : 0,
            y : 0
        };
        if (!b) {
            f.target = g;
            f.view = window
        }
        if (a) {
            Ext.iterate(f, function(h, i) {
                if (a.hasOwnProperty(h)) {
                    f[h] = a[h]
                }
            })
        }
        e.forEach(function(h) {
            if (f[h + "X"] != 0) {
                d.x = f[h + "X"]
            }
            if (f[h + "Y"] != 0) {
                d.y = f[h + "Y"]
            }
        });
        e.forEach(function(h) {
            if (f[h + "X"] == 0 && d.x != 0) {
                f[h + "X"] = d.x
            }
            if (f[h + "Y"] == 0 && d.y != 0) {
                f[h + "Y"] = d.y
            }
        });
        return f
    },
    createMouseEvent : function(a, b) {
        var c = document.createEvent("MouseEvents");
        c.initMouseEvent(a, b.bubbles, b.cancelable, b.view, b.detail,
                b.screenX, b.screenY, b.clientX, b.clientY, b.ctrlKey,
                b.altKey, b.shiftKey, b.metaKey, b.button, b.relatedTarget);
        return c
    }
});
Ext.util.EventRecorder = Ext
        .extend(
                Ext.util.Observable,
                {
                    eventCollection : null,
                    currentEventSetName : null,
                    constructor : function() {
                        this.addEvents("replaystart", "beforecalculatetarget",
                                "beforefire", "afterfire",
                                "aftercalculatetarget", "replayend",
                                "interrupted");
                        this.eventSets = {};
                        this.interruptedIndexes = {};
                        return this
                    },
                    getEventSet : function(a) {
                        if (typeof a != "string") {
                            if (this.currentEventSetName == null) {
                                throw new Error("No EventSet is currently used")
                            }
                            a = this.currentEventSetName
                        }
                        if (typeof this.eventSets[a] == "undefined") {
                            this.eventSets[a] = []
                        }
                        return this.eventSets[a]
                    },
                    start : function(a) {
                        this.currentEventSetName = a
                    },
                    record : function(a, c) {
                        if (typeof a != "string") {
                            if (this.currentEventSetName == null) {
                                return
                            }
                            c = a;
                            a = this.currentEventSetName
                        }
                        var b = this.getEventSimulator().createEventData(c,
                                true);
                        this.getEventSet(a).push(b)
                    },
                    setEventSet : function(a, b) {
                        this.eventSets[a] = b
                    },
                    erase : function(a) {
                        this.getEventSet(a).length = 0
                    },
                    stopReplay : function() {
                        this.interruptFlag = true
                    },
                    resumeReplay : function(b) {
                        var a = this.interruptedIndexes[b] || 0;
                        this.replay(b, a)
                    },
                    replay : function(c, j) {
                        var l = this.getEventSimulator(), k = this
                                .getEventSet(c), i, d = 0, e = 0, b, h, f, a = [
                                "touchmove", "touchend", "mousemove", "mouseup" ], g = this;
                        if (typeof j == "undefined") {
                            j = 0
                        }
                        e = j;
                        i = k.length;
                        this.interruptFlag = false;
                        if (i > 0) {
                            this.fireEvent("replaystart", c, j);
                            setTimeout(
                                    function() {
                                        b = k[e];
                                        if (b) {
                                            if (a.indexOf(b.type) === -1) {
                                                g
                                                        .fireEvent(
                                                                "beforecalculatetarget",
                                                                b.type, b);
                                                h = Ext.util.Point.fromEvent(b);
                                                f = document.elementFromPoint(
                                                        h.x, h.y);
                                                g.fireEvent(
                                                        "aftercalculatetarget",
                                                        b.type, f, b)
                                            }
                                            if (f) {
                                                if (g.interruptFlag === true) {
                                                    g.interruptFlag = false;
                                                    g.interruptedIndexes[c] = e;
                                                    g.fireEvent("interrupted",
                                                            e);
                                                    g.fireEvent("replayend", c,
                                                            true);
                                                    return
                                                }
                                                g.fireEvent("beforefire",
                                                        b.type, f, b);
                                                l.fire(b.type, f, b);
                                                g.fireEvent("afterfire",
                                                        b.type, f, b)
                                            }
                                            if (++e < i) {
                                                setTimeout(arguments.callee,
                                                        k[e].timeStamp
                                                                - b.timeStamp)
                                            } else {
                                                g.fireEvent("replayend", c,
                                                        false)
                                            }
                                        }
                                    }, d)
                        }
                    },
                    end : function() {
                        this.currentEventSetName = null
                    },
                    getEventSimulator : function() {
                        if (!this._eventSimulator) {
                            this._eventSimulator = new Ext.util.EventSimulator()
                        }
                        return this._eventSimulator
                    },
                    setEventSimulator : function(a) {
                        if (!(a instanceof Ext.util.EventSimulator)) {
                            throw new Error(
                                    "eventSimulator must be an instance of Ext.util.EventSimulator")
                        }
                        this._eventSimulator = a
                    },
                    save : function(a) {
                    }
                });
Ext.gesture.Manager = new Ext.AbstractManager(
        {
            eventNames : {
                start : "touchstart",
                move : "touchmove",
                end : "touchend"
            },
            defaultPreventedMouseEvents : [ "click" ],
            clickMoveThreshold : 5,
            init : function() {
                this.targets = [];
                this.followTouches = [];
                this.currentGestures = [];
                this.currentTargets = [];
                if (!Ext.supports.Touch) {
                    Ext.apply(this.eventNames, {
                        start : "mousedown",
                        move : "mousemove",
                        end : "mouseup"
                    })
                }
                this.listenerWrappers = {
                    start : Ext.createDelegate(this.onTouchStart, this),
                    move : Ext.createDelegate(this.onTouchMove, this),
                    end : Ext.createDelegate(this.onTouchEnd, this),
                    mouse : Ext.createDelegate(this.onMouseEvent, this)
                };
                this.attachListeners()
            },
            freeze : function() {
                this.isFrozen = true
            },
            thaw : function() {
                this.isFrozen = false
            },
            getEventSimulator : function() {
                if (!this.eventSimulator) {
                    this.eventSimulator = new Ext.util.EventSimulator()
                }
                return this.eventSimulator
            },
            attachListeners : function() {
                Ext.iterate(this.eventNames, function(b, a) {
                    document.addEventListener(a, this.listenerWrappers[b],
                            false)
                }, this);
                if (Ext.supports.Touch) {
                    this.defaultPreventedMouseEvents.forEach(function(a) {
                        document.addEventListener(a,
                                this.listenerWrappers.mouse, true)
                    }, this)
                }
            },
            detachListeners : function() {
                Ext.iterate(this.eventNames, function(b, a) {
                    document.removeEventListener(a, this.listenerWrappers[b],
                            false)
                }, this);
                if (Ext.supports.Touch) {
                    this.defaultPreventedMouseEvents.forEach(function(a) {
                        document.removeEventListener(a,
                                this.listenerWrappers.mouse, true)
                    }, this)
                }
            },
            onMouseEvent : function(a) {
                if (!a.isSimulated) {
                    a.preventDefault();
                    a.stopPropagation()
                }
            },
            onTouchStart : function(c) {
                var a = [], b = c.target;
                if (c.stopped === true) {
                    return
                }
                if (Ext.is.Android) {
                    if (!(b.tagName && [ "input", "textarea", "select" ]
                            .indexOf(b.tagName.toLowerCase()) !== -1)) {
                        c.preventDefault()
                    }
                }
                if (this.isFrozen) {
                    return
                }
                if (this.startEvent) {
                    this.onTouchEnd(c)
                }
                this.locks = {};
                this.currentTargets = [ b ];
                while (b) {
                    if (this.targets.indexOf(b) !== -1) {
                        a.unshift(b)
                    }
                    b = b.parentNode;
                    this.currentTargets.push(b)
                }
                this.startEvent = c;
                this.startPoint = Ext.util.Point.fromEvent(c);
                this.lastMovePoint = null;
                this.isClick = true;
                this.handleTargets(a, c)
            },
            onTouchMove : function(c) {
                if (Ext.is.MultiTouch) {
                    c.preventDefault()
                }
                if (!this.startEvent) {
                    return
                }
                if (Ext.is.Desktop) {
                    c.target = this.startEvent.target
                }
                if (this.isFrozen) {
                    return
                }
                var d = this.currentGestures, b, f = c.changedTouches ? c.changedTouches[0]
                        : c;
                this.lastMovePoint = Ext.util.Point.fromEvent(c);
                if (Ext.supports.Touch
                        && this.isClick
                        && !this.lastMovePoint.isWithin(this.startPoint,
                                this.clickMoveThreshold)) {
                    this.isClick = false
                }
                for ( var a = 0; a < d.length; a++) {
                    if (c.stopped) {
                        break
                    }
                    b = d[a];
                    if (b.listenForMove) {
                        b.onTouchMove(c, f)
                    }
                }
            },
            onTouchEnd : function(g) {
                if (Ext.is.Blackberry) {
                    g.preventDefault()
                }
                if (this.isFrozen) {
                    return
                }
                var h = this.currentGestures.slice(0), d = h.length, c, b, a, f = false, j = g.changedTouches ? g.changedTouches[0]
                        : g;
                if (this.startPoint) {
                    a = Ext.util.Point.fromEvent(g);
                    if (!(this.lastMovePoint || this.startPoint)["equals"](a)) {
                        f = true
                    }
                }
                for (c = 0; c < d; c++) {
                    b = h[c];
                    if (!g.stopped && b.listenForEnd) {
                        if (f) {
                            b.onTouchMove(g, j)
                        }
                        b.onTouchEnd(g, j)
                    }
                    this.stopGesture(b)
                }
                if (Ext.supports.Touch && this.isClick) {
                    this.isClick = false;
                    this.getEventSimulator().fire("click",
                            this.startEvent.target, j)
                }
                this.lastMovePoint = null;
                this.followTouches = [];
                this.startedChangedTouch = false;
                this.currentTargets = [];
                this.startEvent = null;
                this.startPoint = null
            },
            handleTargets : function(a, d) {
                var c = a.length, b;
                this.startedChangedTouch = false;
                this.startedTouches = Ext.supports.Touch ? d.touches : [ d ];
                for (b = 0; b < c; b++) {
                    if (d.stopped) {
                        break
                    }
                    this.handleTarget(a[b], d, true)
                }
                for (b = c - 1; b >= 0; b--) {
                    if (d.stopped) {
                        break
                    }
                    this.handleTarget(a[b], d, false)
                }
                if (this.startedChangedTouch) {
                    this.followTouches = this.followTouches
                            .concat((Ext.supports.Touch && d.targetTouches) ? Ext
                                    .toArray(d.targetTouches)
                                    : [ d ])
                }
            },
            handleTarget : function(g, f, a) {
                var h = Ext.Element.data(g, "x-gestures") || [], d = h.length, c, b;
                for (c = 0; c < d; c++) {
                    b = h[c];
                    if ((!!b.capture === !!a)
                            && (this.followTouches.length < b.touches)
                            && ((Ext.supports.Touch && f.targetTouches) ? (f.targetTouches.length === b.touches)
                                    : true)) {
                        this.startedChangedTouch = true;
                        this.startGesture(b);
                        if (b.listenForStart) {
                            b.onTouchStart(f,
                                    f.changedTouches ? f.changedTouches[0] : f)
                        }
                        if (f.stopped) {
                            break
                        }
                    }
                }
            },
            startGesture : function(a) {
                a.started = true;
                this.currentGestures.push(a)
            },
            stopGesture : function(a) {
                a.started = false;
                this.currentGestures.remove(a)
            },
            addEventListener : function(g, b, f, d) {
                g = Ext.getDom(g);
                d = d || {};
                var a = this.targets, c = this.getGestureName(b), h = Ext.Element
                        .data(g, "x-gestures"), e;
                if (!h) {
                    h = [];
                    Ext.Element.data(g, "x-gestures", h)
                }
                if (!c) {
                    throw new Error("Trying to subscribe to unknown event " + b)
                }
                if (a.indexOf(g) === -1) {
                    this.targets.push(g)
                }
                e = this.get(g.id + "-" + c);
                if (!e) {
                    e = this.create(Ext.apply({}, d, {
                        target : g,
                        type : c
                    }));
                    h.push(e)
                }
                e.addListener(b, f);
                if (this.startedChangedTouch && this.currentTargets.contains(g)
                        && !e.started && !d.subsequent) {
                    this.startGesture(e);
                    if (e.listenForStart) {
                        e.onTouchStart(this.startEvent, this.startedTouches[0])
                    }
                }
            },
            removeEventListener : function(e, a, d) {
                e = Ext.getDom(e);
                var b = this.getGestureName(a), f = Ext.Element.data(e,
                        "x-gestures")
                        || [], c;
                c = this.get(e.id + "-" + b);
                if (c) {
                    c.removeListener(a, d);
                    for (b in c.listeners) {
                        return
                    }
                    c.destroy();
                    f.remove(c);
                    Ext.Element.data(e, "x-gestures", f)
                }
            },
            getGestureName : function(a) {
                return this.names && this.names[a]
            },
            registerType : function(d, a) {
                var c = a.prototype.handles, b, e;
                this.types[d] = a;
                a[this.typeName] = d;
                if (!c) {
                    c = a.prototype.handles = [ d ]
                }
                this.names = this.names || {};
                for (b = 0, e = c.length; b < e; b++) {
                    this.names[c[b]] = d
                }
            }
        });
Ext.regGesture = function() {
    return Ext.gesture.Manager.registerType.apply(Ext.gesture.Manager,
            arguments)
};
Ext.TouchEventObjectImpl = Ext.extend(Object, {
    constructor : function(b, a) {
        if (b) {
            this.setEvent(b, a)
        }
    },
    setEvent : function(b, a) {
        Ext.apply(this, {
            event : b,
            time : b.timeStamp
        });
        this.touches = b.touches || [ b ];
        this.changedTouches = b.changedTouches || [ b ];
        this.targetTouches = b.targetTouches || [ b ];
        if (a) {
            this.target = a.target;
            Ext.apply(this, a)
        } else {
            this.target = b.target
        }
        return this
    },
    stopEvent : function() {
        this.stopPropagation();
        this.preventDefault()
    },
    stopPropagation : function() {
        this.event.stopped = true
    },
    preventDefault : function() {
        this.event.preventDefault()
    },
    getTarget : function(b, c, a) {
        if (b) {
            return Ext.fly(this.target).findParent(b, c, a)
        } else {
            return a ? Ext.get(this.target) : this.target
        }
    }
});
Ext.TouchEventObject = new Ext.TouchEventObjectImpl();
Ext.gesture.Gesture = Ext.extend(Object, {
    listenForStart : true,
    listenForEnd : true,
    listenForMove : true,
    disableLocking : false,
    touches : 1,
    constructor : function(a) {
        a = a || {};
        Ext.apply(this, a);
        this.target = Ext.getDom(this.target);
        this.listeners = {};
        if (!this.target) {
            throw new Error("Trying to bind a " + this.type
                    + " event to element that does'nt exist: " + this.target)
        }
        this.id = this.target.id + "-" + this.type;
        Ext.gesture.Gesture.superclass.constructor.call(this);
        Ext.gesture.Manager.register(this)
    },
    addListener : function(a, b) {
        this.listeners[a] = this.listeners[a] || [];
        this.listeners[a].push(b)
    },
    removeListener : function(a, c) {
        var b = this.listeners[a];
        if (b) {
            b.remove(c);
            if (b.length == 0) {
                delete this.listeners[a]
            }
            for (a in this.listeners) {
                if (this.listeners.hasOwnProperty(a)) {
                    return
                }
            }
            this.listeners = {}
        }
    },
    fire : function(d, g, a) {
        var c = this.listeners && this.listeners[d], f = c && c.length, b;
        if (!this.disableLocking && this.isLocked(d)) {
            return false
        }
        if (f) {
            a = Ext.apply(a || {}, {
                time : g.timeStamp,
                type : d,
                gesture : this,
                target : (g.target.nodeType == 3) ? g.target.parentNode
                        : g.target
            });
            for (b = 0; b < f; b++) {
                c[b](g, a)
            }
        }
        return true
    },
    stop : function() {
        Ext.gesture.Manager.stopGesture(this)
    },
    lock : function() {
        if (!this.disableLocking) {
            var a = arguments, c = a.length, b;
            for (b = 0; b < c; b++) {
                Ext.gesture.Manager.locks[a[b]] = this.id
            }
        }
    },
    unlock : function() {
        if (!this.disableLocking) {
            var a = arguments, c = a.length, b;
            for (b = 0; b < c; b++) {
                if (Ext.gesture.Manager.locks[a[b]] == this.id) {
                    delete Ext.gesture.Manager.locks[a[b]]
                }
            }
        }
    },
    isLocked : function(b) {
        var a = Ext.gesture.Manager.locks[b];
        return !!(a && a !== this.id)
    },
    getLockingGesture : function(b) {
        var a = Ext.gesture.Manager.locks[b];
        if (a) {
            return Ext.gesture.Manager.get(a) || null
        }
        return null
    },
    onTouchStart : Ext.emptyFn,
    onTouchMove : Ext.emptyFn,
    onTouchEnd : Ext.emptyFn,
    destroy : function() {
        this.stop();
        this.listeners = null;
        Ext.gesture.Manager.unregister(this)
    }
});
Ext.gesture.Touch = Ext.extend(Ext.gesture.Gesture, {
    handles : [ "touchstart", "touchmove", "touchend", "touchdown" ],
    touchDownInterval : 500,
    onTouchStart : function(a, b) {
        this.startX = this.previousX = b.pageX;
        this.startY = this.previousY = b.pageY;
        this.startTime = this.previousTime = a.timeStamp;
        this.fire("touchstart", a);
        this.lastEvent = a;
        if (this.listeners && this.listeners.touchdown) {
            this.touchDownIntervalId = setInterval(Ext.createDelegate(
                    this.touchDownHandler, this), this.touchDownInterval)
        }
    },
    onTouchMove : function(a, b) {
        this.fire("touchmove", a, this.getInfo(b));
        this.lastEvent = a
    },
    onTouchEnd : function(a) {
        this.fire("touchend", a, this.lastInfo);
        clearInterval(this.touchDownIntervalId)
    },
    touchDownHandler : function() {
        this.fire("touchdown", this.lastEvent, this.lastInfo)
    },
    getInfo : function(e) {
        var d = Date.now(), b = e.pageX - this.startX, a = e.pageY
                - this.startY, c = {
            startX : this.startX,
            startY : this.startY,
            previousX : this.previousX,
            previousY : this.previousY,
            pageX : e.pageX,
            pageY : e.pageY,
            deltaX : b,
            deltaY : a,
            absDeltaX : Math.abs(b),
            absDeltaY : Math.abs(a),
            previousDeltaX : e.pageX - this.previousX,
            previousDeltaY : e.pageY - this.previousY,
            time : d,
            startTime : this.startTime,
            previousTime : this.previousTime,
            deltaTime : d - this.startTime,
            previousDeltaTime : d - this.previousTime
        };
        this.previousTime = c.time;
        this.previousX = c.pageX;
        this.previousY = c.pageY;
        this.lastInfo = c;
        return c
    }
});
Ext.regGesture("touch", Ext.gesture.Touch);
Ext.gesture.Tap = Ext.extend(Ext.gesture.Gesture, {
    handles : [ "tapstart", "tapcancel", "tap", "doubletap", "taphold",
            "singletap" ],
    cancelThreshold : 10,
    doubleTapThreshold : 800,
    singleTapThreshold : 400,
    holdThreshold : 1000,
    fireClickEvent : false,
    onTouchStart : function(b, c) {
        var a = this;
        a.startX = c.pageX;
        a.startY = c.pageY;
        a.fire("tapstart", b, a.getInfo(c));
        if (this.listeners.taphold) {
            a.timeout = setTimeout(function() {
                a.fire("taphold", b, a.getInfo(c));
                delete a.timeout
            }, a.holdThreshold)
        }
        a.lastTouch = c
    },
    onTouchMove : function(b, c) {
        var a = this;
        if (a.isCancel(c)) {
            a.fire("tapcancel", b, a.getInfo(c));
            if (a.timeout) {
                clearTimeout(a.timeout);
                delete a.timeout
            }
            a.stop()
        }
        a.lastTouch = c
    },
    onTouchEnd : function(c) {
        var a = this, b = a.getInfo(a.lastTouch);
        this.fireTapEvent(c, b);
        if (a.lastTapTime
                && c.timeStamp - a.lastTapTime <= a.doubleTapThreshold) {
            a.lastTapTime = null;
            c.preventDefault();
            a.fire("doubletap", c, b)
        } else {
            a.lastTapTime = c.timeStamp
        }
        if (a.listeners && a.listeners.singletap && a.singleTapThreshold
                && !a.preventSingleTap) {
            a.fire("singletap", c, b);
            a.preventSingleTap = true;
            setTimeout(function() {
                a.preventSingleTap = false
            }, a.singleTapThreshold)
        }
        if (a.timeout) {
            clearTimeout(a.timeout);
            delete a.timeout
        }
    },
    fireTapEvent : function(d, c) {
        this.fire("tap", d, c);
        if (d.event) {
            d = d.event
        }
        var b = (d.changedTouches ? d.changedTouches[0] : d).target;
        if (!b.disabled && this.fireClickEvent) {
            var a = document.createEvent("MouseEvent");
            a.initMouseEvent("click", d.bubbles, d.cancelable,
                    document.defaultView, d.detail, d.screenX, d.screenY,
                    d.clientX, d.clientY, d.ctrlKey, d.altKey, d.shiftKey,
                    d.metaKey, d.metaKey, d.button, d.relatedTarget);
            a.isSimulated = true;
            b.dispatchEvent(a)
        }
    },
    getInfo : function(c) {
        var a = c.pageX, b = c.pageY;
        return {
            pageX : a,
            pageY : b,
            startX : a,
            startY : b
        }
    },
    isCancel : function(b) {
        var a = this;
        return (Math.abs(b.pageX - a.startX) >= a.cancelThreshold || Math
                .abs(b.pageY - a.startY) >= a.cancelThreshold)
    }
});
Ext.regGesture("tap", Ext.gesture.Tap);
Ext.gesture.Swipe = Ext.extend(Ext.gesture.Gesture, {
    listenForEnd : false,
    swipeThreshold : 35,
    swipeTime : 1000,
    onTouchStart : function(a, b) {
        this.startTime = a.timeStamp;
        this.startX = b.pageX;
        this.startY = b.pageY;
        this.lock("scroll", "scrollstart", "scrollend")
    },
    onTouchMove : function(g, h) {
        var b = h.pageY - this.startY, d = h.pageX - this.startX, a = Math
                .abs(b), c = Math.abs(d), f = g.timeStamp - this.startTime;
        if (a - c > 3 || f > this.swipeTime) {
            this.unlock("drag", "dragstart", "dragend");
            this.stop()
        } else {
            if (c > this.swipeThreshold && c > a) {
                this.fire("swipe", g, {
                    direction : (d < 0) ? "left" : "right",
                    distance : c,
                    deltaTime : f,
                    deltaX : d
                });
                this.stop()
            }
        }
    }
});
Ext.regGesture("swipe", Ext.gesture.Swipe);
Ext.gesture.Drag = Ext
        .extend(
                Ext.gesture.Touch,
                {
                    handles : [ "dragstart", "drag", "dragend" ],
                    dragThreshold : 5,
                    direction : "both",
                    horizontal : false,
                    vertical : false,
                    constructor : function() {
                        var a = this;
                        Ext.gesture.Drag.superclass.constructor.apply(a,
                                arguments);
                        if (a.direction == "both") {
                            a.horizontal = true;
                            a.vertical = true
                        } else {
                            if (a.direction == "horizontal") {
                                a.horizontal = true
                            } else {
                                a.vertical = true
                            }
                        }
                        return a
                    },
                    onTouchStart : function(b, c) {
                        var a = this;
                        a.startX = a.previousX = c.pageX;
                        a.startY = a.previousY = c.pageY;
                        a.startTime = a.previousTime = b.timeStamp;
                        a.dragging = false
                    },
                    onTouchMove : function(c, d) {
                        var a = this;
                        if (a.isLocked("drag")) {
                            return
                        }
                        var b = a.getInfo(d);
                        if (!a.dragging) {
                            if ((!c.touches || c.touches.length < 2)
                                    && a.isDragging(b)
                                    && a.fire("dragstart", c, b)) {
                                a.dragging = true;
                                a.lock("drag", "dragstart", "dragend");
                                a.fire("drag", c, b)
                            }
                        } else {
                            a.fire("drag", c, b)
                        }
                    },
                    onTouchEnd : function(b) {
                        var a = this;
                        if (a.dragging) {
                            a.fire("dragend", b, a.lastInfo)
                        }
                        a.dragging = false
                    },
                    isDragging : function(b) {
                        var a = this;
                        return ((a.horizontal && b.absDeltaX >= a.dragThreshold) || (a.vertical && b.absDeltaY >= a.dragThreshold))
                    },
                    isVertical : function() {
                        return this.vertical
                    },
                    isHorizontal : function() {
                        return this.horizontal
                    }
                });
Ext.regGesture("drag", Ext.gesture.Drag);
Ext.gesture.Pinch = Ext.extend(Ext.gesture.Gesture, {
    handles : [ "pinchstart", "pinch", "pinchend" ],
    touches : 2,
    onTouchStart : function(c) {
        var a = this;
        if (this.isMultiTouch(c)) {
            a.lock("swipe", "scroll", "scrollstart", "scrollend", "touchmove",
                    "touchend", "touchstart", "tap", "tapstart", "taphold",
                    "tapcancel", "doubletap");
            a.pinching = true;
            var b = c.targetTouches;
            a.startFirstTouch = b[0];
            a.startSecondTouch = b[1];
            a.previousDistance = a.startDistance = a.getDistance(
                    a.startFirstTouch, a.startSecondTouch);
            a.previousScale = 1;
            a.fire("pinchstart", c, {
                distance : a.startDistance,
                scale : a.previousScale
            })
        } else {
            if (a.pinching) {
                a.unlock("swipe", "scroll", "scrollstart", "scrollend",
                        "touchmove", "touchend", "touchstart", "tap",
                        "tapstart", "taphold", "tapcancel", "doubletap");
                a.pinching = false
            }
        }
    },
    isMultiTouch : function(a) {
        return a && Ext.supports.Touch && a.targetTouches
                && a.targetTouches.length > 1
    },
    onTouchMove : function(a) {
        if (!this.isMultiTouch(a)) {
            this.onTouchEnd(a);
            return
        }
        if (this.pinching) {
            this.fire("pinch", a, this.getPinchInfo(a))
        }
    },
    onTouchEnd : function(a) {
        if (this.pinching) {
            this.fire("pinchend", a)
        }
    },
    getPinchInfo : function(g) {
        var b = this, c = g.targetTouches, f = c[0], a = c[1], i = b
                .getDistance(f, a), h = i / b.startDistance, d = {
            scale : h,
            deltaScale : h - 1,
            previousScale : b.previousScale,
            previousDeltaScale : h - b.previousScale,
            distance : i,
            deltaDistance : i - b.startDistance,
            startDistance : b.startDistance,
            previousDistance : b.previousDistance,
            previousDeltaDistance : i - b.previousDistance,
            firstTouch : f,
            secondTouch : a,
            firstPageX : f.pageX,
            firstPageY : f.pageY,
            secondPageX : a.pageX,
            secondPageY : a.pageY,
            midPointX : (f.pageX + a.pageX) / 2,
            midPointY : (f.pageY + a.pageY) / 2
        };
        b.previousScale = h;
        b.previousDistance = i;
        return d
    },
    getDistance : function(b, a) {
        return Math.sqrt(Math.pow(Math.abs(b.pageX - a.pageX), 2)
                + Math.pow(Math.abs(b.pageY - a.pageY), 2))
    }
});
Ext.regGesture("pinch", Ext.gesture.Pinch);
Ext.lib.Component = Ext
        .extend(
                Ext.util.Observable,
                {
                    isComponent : true,
                    renderTpl : null,
                    tplWriteMode : "overwrite",
                    baseCls : "x-component",
                    disabledCls : "x-item-disabled",
                    hidden : false,
                    disabled : false,
                    draggable : false,
                    floating : false,
                    styleHtmlContent : false,
                    styleHtmlCls : "x-html",
                    allowDomMove : true,
                    autoShow : false,
                    autoRender : false,
                    needsLayout : false,
                    rendered : false,
                    constructor : function(b) {
                        b = b || {};
                        this.initialConfig = b;
                        Ext.apply(this, b);
                        this.addEvents("beforeactivate", "activate",
                                "beforedeactivate", "deactivate", "added",
                                "disable", "enable", "beforeshow", "show",
                                "beforehide", "hide", "removed",
                                "beforerender", "render", "afterrender",
                                "beforedestroy", "destroy", "resize", "move",
                                "beforestaterestore", "staterestore",
                                "beforestatesave", "statesave");
                        this.getId();
                        this.mons = [];
                        this.additionalCls = [];
                        this.renderData = this.renderData || {};
                        this.renderSelectors = this.renderSelectors || {};
                        this.initComponent();
                        Ext.ComponentMgr.register(this);
                        Ext.lib.Component.superclass.constructor.call(this);
                        if (this.plugins) {
                            this.plugins = [].concat(this.plugins);
                            for ( var c = 0, a = this.plugins.length; c < a; c++) {
                                this.plugins[c] = this
                                        .initPlugin(this.plugins[c])
                            }
                        }
                        if (this.applyTo) {
                            this.applyToMarkup(this.applyTo);
                            delete this.applyTo
                        } else {
                            if (this.renderTo) {
                                this.render(this.renderTo);
                                delete this.renderTo
                            }
                        }
                        if (Ext.isDefined(this.disabledClass)) {
                            throw "Component: disabledClass has been deprecated. Please use disabledCls."
                        }
                    },
                    initComponent : Ext.emptyFn,
                    applyToMarkup : Ext.emptyFn,
                    show : Ext.emptyFn,
                    onShow : function() {
                        var a = this.needsLayout;
                        if (Ext.isObject(a)) {
                            this.doComponentLayout(a.width, a.height,
                                    a.isSetSize)
                        }
                    },
                    initPlugin : function(a) {
                        if (a.ptype && typeof a.init != "function") {
                            a = Ext.PluginMgr.create(a)
                        } else {
                            if (typeof a == "string") {
                                a = Ext.PluginMgr.create({
                                    ptype : a
                                })
                            }
                        }
                        a.init(this);
                        return a
                    },
                    render : function(b, a) {
                        if (!this.rendered
                                && this.fireEvent("beforerender", this) !== false) {
                            if (this.el) {
                                this.el = Ext.get(this.el)
                            }
                            b = this.initContainer(b);
                            this.onRender(b, a);
                            this.fireEvent("render", this);
                            this.initContent();
                            this.afterRender(b);
                            this.fireEvent("afterrender", this);
                            this.initEvents();
                            if (this.autoShow) {
                                this.show()
                            }
                            if (this.hidden) {
                                this.onHide(false)
                            }
                            if (this.disabled) {
                                this.disable(true)
                            }
                        }
                        return this
                    },
                    onRender : function(b, a) {
                        var c = this.el, e, d;
                        a = this.getInsertPosition(a);
                        if (!c) {
                            if (a) {
                                c = Ext.DomHelper.insertBefore(a, this
                                        .getElConfig(), true)
                            } else {
                                c = Ext.DomHelper.append(b, this.getElConfig(),
                                        true)
                            }
                        } else {
                            if (this.allowDomMove !== false) {
                                b.dom.insertBefore(c.dom, a)
                            }
                        }
                        c.addCls(this.initCls());
                        c.setStyle(this.initStyles());
                        e = this.initRenderTpl();
                        if (e) {
                            d = this.initRenderData();
                            e.append(c, d)
                        }
                        this.el = c;
                        this.applyRenderSelectors();
                        this.rendered = true
                    },
                    initCls : function() {
                        var a = [ this.baseCls ];
                        if (this.componentCls) {
                            a.push(this.componentCls)
                        } else {
                            this.componentCls = this.baseCls
                        }
                        if (this.cls) {
                            a.push(this.cls);
                            delete this.cls
                        }
                        if (this.ui) {
                            a.push(this.componentCls + "-" + this.ui)
                        }
                        return a.concat(this.additionalCls)
                    },
                    afterRender : function() {
                        this.getComponentLayout();
                        if (this.x || this.y) {
                            this.setPosition(this.x, this.y)
                        }
                        if (this.styleHtmlContent) {
                            this.getTargetEl().addCls(this.styleHtmlCls)
                        }
                        if (!this.ownerCt) {
                            this.setSize(this.width, this.height)
                        }
                    },
                    getElConfig : function() {
                        return {
                            tag : "div",
                            id : this.id
                        }
                    },
                    getInsertPosition : function(a) {
                        if (a !== undefined) {
                            if (Ext.isNumber(a)) {
                                a = this.container.dom.childNodes[a]
                            } else {
                                a = Ext.getDom(a)
                            }
                        }
                        return a
                    },
                    initContainer : function(a) {
                        if (!a && this.el) {
                            a = this.el.dom.parentNode;
                            this.allowDomMove = false
                        }
                        this.container = Ext.get(a);
                        if (this.ctCls) {
                            this.container.addCls(this.ctCls)
                        }
                        return this.container
                    },
                    initRenderData : function() {
                        return Ext.applyIf(this.renderData, {
                            baseCls : this.baseCls,
                            componentCls : this.componentCls
                        })
                    },
                    initRenderTpl : function() {
                        var a = this.renderTpl;
                        if (a) {
                            if (this.proto.renderTpl !== a) {
                                if (Ext.isArray(a) || typeof a === "string") {
                                    a = new Ext.XTemplate(a)
                                }
                            } else {
                                if (Ext.isArray(this.proto.renderTpl)) {
                                    a = this.proto.renderTpl = new Ext.XTemplate(
                                            a)
                                }
                            }
                        }
                        return a
                    },
                    initStyles : function() {
                        var d = {}, a = Ext.Element, c, e, b, f;
                        if (Ext.isString(this.style)) {
                            b = this.style.split(";");
                            for (c = 0, e = b.length; c < e; c++) {
                                if (!Ext.isEmpty(b[c])) {
                                    f = b[c].split(":");
                                    d[Ext.util.Format.trim(f[0])] = Ext.util.Format
                                            .trim(f[1])
                                }
                            }
                        } else {
                            d = Ext.apply({}, this.style)
                        }
                        if (this.padding != undefined) {
                            d.padding = a
                                    .unitizeBox((this.padding === true) ? 5
                                            : this.padding)
                        }
                        if (this.margin != undefined) {
                            d.margin = a.unitizeBox((this.margin === true) ? 5
                                    : this.margin)
                        }
                        if (this.border != undefined) {
                            d.borderWidth = a
                                    .unitizeBox((this.border === true) ? 1
                                            : this.border)
                        }
                        delete this.style;
                        return d
                    },
                    initContent : function() {
                        var b = this.getTargetEl();
                        if (this.html) {
                            b.update(Ext.DomHelper.markup(this.html));
                            delete this.html
                        }
                        if (this.contentEl) {
                            var a = Ext.get(this.contentEl);
                            a.show();
                            b.appendChild(a.dom)
                        }
                        if (this.tpl) {
                            if (!this.tpl.isTemplate) {
                                this.tpl = new Ext.XTemplate(this.tpl)
                            }
                            if (this.data) {
                                this.tpl[this.tplWriteMode](b, this.data);
                                delete this.data
                            }
                        }
                    },
                    initEvents : function() {
                        var c = this.afterRenderEvents, b, a;
                        if (c) {
                            for (b in c) {
                                if (!c.hasOwnProperty(b)) {
                                    continue
                                }
                                a = c[b];
                                if (this[b] && this[b].on) {
                                    this.mon(this[b], a)
                                }
                            }
                        }
                    },
                    applyRenderSelectors : function() {
                        var b = this.renderSelectors || {}, c = this.el.dom, a;
                        for (a in b) {
                            if (!b.hasOwnProperty(a)) {
                                continue
                            }
                            this[a] = Ext.get(Ext.DomQuery.selectNode(b[a], c))
                        }
                    },
                    is : function(a) {
                        return Ext.ComponentQuery.is(this, a)
                    },
                    up : function(b) {
                        var a = this.ownerCt;
                        if (b) {
                            for (; a; a = a.ownerCt) {
                                if (Ext.ComponentQuery.is(a, b)) {
                                    return a
                                }
                            }
                        }
                        return a
                    },
                    nextSibling : function(b) {
                        var f = this.ownerCt, d, e, a, g;
                        if (f) {
                            d = f.items;
                            a = d.indexOf(this) + 1;
                            if (a) {
                                if (b) {
                                    for (e = d.getCount(); a < e; a++) {
                                        if ((g = d.getAt(a)).is(b)) {
                                            return g
                                        }
                                    }
                                } else {
                                    if (a < d.getCount()) {
                                        return d.getAt(a)
                                    }
                                }
                            }
                        }
                        return null
                    },
                    previousSibling : function(b) {
                        var e = this.ownerCt, d, a, f;
                        if (e) {
                            d = e.items;
                            a = d.indexOf(this);
                            if (a != -1) {
                                if (b) {
                                    for (--a; a >= 0; a--) {
                                        if ((f = d.getAt(a)).is(b)) {
                                            return f
                                        }
                                    }
                                } else {
                                    if (a) {
                                        return d.getAt(--a)
                                    }
                                }
                            }
                        }
                        return null
                    },
                    getId : function() {
                        return this.id
                                || (this.id = "ext-comp-"
                                        + (++Ext.lib.Component.AUTO_ID))
                    },
                    getItemId : function() {
                        return this.itemId || this.id
                    },
                    getEl : function() {
                        return this.el
                    },
                    getTargetEl : function() {
                        return this.el
                    },
                    isXType : function(b, a) {
                        if (Ext.isFunction(b)) {
                            b = b.xtype
                        } else {
                            if (Ext.isObject(b)) {
                                b = b.constructor.xtype
                            }
                        }
                        return !a ? ("/" + this.getXTypes() + "/").indexOf("/"
                                + b + "/") != -1 : this.constructor.xtype == b
                    },
                    getXTypes : function() {
                        var a = this.constructor, b = [], d = this, c;
                        if (!a.xtypes) {
                            while (d) {
                                c = d.constructor.xtype;
                                if (c != undefined) {
                                    b.unshift(c)
                                }
                                d = d.constructor.superclass
                            }
                            a.xtypeChain = b;
                            a.xtypes = b.join("/")
                        }
                        return a.xtypes
                    },
                    update : function(b, c, a) {
                        if (this.tpl && !Ext.isString(b)) {
                            this.data = b;
                            if (this.rendered) {
                                this.tpl[this.tplWriteMode](this.getTargetEl(),
                                        b || {})
                            }
                        } else {
                            this.html = Ext.isObject(b) ? Ext.DomHelper
                                    .markup(b) : b;
                            if (this.rendered) {
                                this.getTargetEl().update(this.html, c, a)
                            }
                        }
                        if (this.rendered) {
                            this.doComponentLayout()
                        }
                    },
                    setVisible : function(a) {
                        return this[a ? "show" : "hide"]()
                    },
                    isVisible : function() {
                        var b = !this.hidden, a = this.ownerCt;
                        this.hiddenOwnerCt = false;
                        if (this.destroyed) {
                            return false
                        }
                        if (b && this.rendered && a) {
                            while (a) {
                                if (a.hidden || a.collapsed) {
                                    this.hiddenOwnerCt = a;
                                    b = false;
                                    break
                                }
                                a = a.ownerCt
                            }
                        }
                        return b
                    },
                    enable : function(a) {
                        if (this.rendered) {
                            this.el.removeCls(this.disabledCls);
                            this.el.dom.disabled = false;
                            this.onEnable()
                        }
                        this.disabled = false;
                        if (a !== true) {
                            this.fireEvent("enable", this)
                        }
                        return this
                    },
                    disable : function(a) {
                        if (this.rendered) {
                            this.el.addCls(this.disabledCls);
                            this.el.dom.disabled = true;
                            this.onDisable()
                        }
                        this.disabled = true;
                        if (a !== true) {
                            this.fireEvent("disable", this)
                        }
                        return this
                    },
                    isDisabled : function() {
                        return this.disabled
                    },
                    setDisabled : function(a) {
                        return this[a ? "disable" : "enable"]()
                    },
                    isHidden : function() {
                        return this.hidden
                    },
                    addCls : function() {
                        var b = this, a = Ext.toArray(arguments);
                        if (b.rendered) {
                            b.el.addCls(a)
                        } else {
                            b.additionalCls = b.additionalCls.concat(a)
                        }
                        return b
                    },
                    addClass : function() {
                        throw "Component: addClass has been deprecated. Please use addCls."
                    },
                    removeCls : function() {
                        var b = this, a = Ext.toArray(arguments);
                        if (b.rendered) {
                            b.el.removeCls(a)
                        } else {
                            if (b.additionalCls.length) {
                                Ext.each(a, function(c) {
                                    b.additionalCls.remove(c)
                                })
                            }
                        }
                        return b
                    },
                    removeClass : function() {
                        throw "Component: removeClass has been deprecated. Please use removeCls."
                    },
                    addListener : function(b, f, e, a) {
                        if (Ext.isString(b)
                                && (Ext.isObject(f) || a && a.element)) {
                            if (a.element) {
                                var d = f, c;
                                f = {};
                                f[b] = d;
                                b = a.element;
                                if (e) {
                                    f.scope = e
                                }
                                for (c in a) {
                                    if (!a.hasOwnProperty(c)) {
                                        continue
                                    }
                                    if (this.eventOptionsRe.test(c)) {
                                        f[c] = a[c]
                                    }
                                }
                            }
                            if (this[b] && this[b].on) {
                                this.mon(this[b], f)
                            } else {
                                this.afterRenderEvents = this.afterRenderEvents
                                        || {};
                                this.afterRenderEvents[b] = f
                            }
                        }
                        return Ext.lib.Component.superclass.addListener.apply(
                                this, arguments)
                    },
                    getBubbleTarget : function() {
                        return this.ownerCt
                    },
                    isFloating : function() {
                        return this.floating
                    },
                    isDraggable : function() {
                        return !!this.draggable
                    },
                    isDroppable : function() {
                        return !!this.droppable
                    },
                    onAdded : function(a, b) {
                        this.ownerCt = a;
                        this.fireEvent("added", this, a, b)
                    },
                    onRemoved : function() {
                        this.fireEvent("removed", this, this.ownerCt);
                        delete this.ownerCt
                    },
                    onEnable : Ext.emptyFn,
                    onDisable : Ext.emptyFn,
                    beforeDestroy : Ext.emptyFn,
                    onResize : Ext.emptyFn,
                    setSize : function(b, a) {
                        if (Ext.isObject(b)) {
                            a = b.height;
                            b = b.width
                        }
                        if (!this.rendered || !this.isVisible()) {
                            if (this.hiddenOwnerCt) {
                                var c = this.hiddenOwnerCt.layoutOnShow;
                                c.remove(this);
                                c.add(this)
                            }
                            this.needsLayout = {
                                width : b,
                                height : a,
                                isSetSize : true
                            };
                            if (!this.rendered) {
                                this.width = (b !== undefined) ? b : this.width;
                                this.height = (a !== undefined) ? a
                                        : this.height
                            }
                            return this
                        }
                        this.doComponentLayout(b, a, true);
                        return this
                    },
                    setCalculatedSize : function(b, a) {
                        if (Ext.isObject(b)) {
                            a = b.height;
                            b = b.width
                        }
                        if (!this.rendered || !this.isVisible()) {
                            if (this.hiddenOwnerCt) {
                                var c = this.hiddenOwnerCt.layoutOnShow;
                                c.remove(this);
                                c.add(this)
                            }
                            this.needsLayout = {
                                width : b,
                                height : a,
                                isSetSize : false
                            };
                            return this
                        }
                        this.doComponentLayout(b, a);
                        return this
                    },
                    doComponentLayout : function(d, a, b) {
                        var c = this.getComponentLayout();
                        if (this.rendered && c) {
                            d = (d !== undefined || this.collapsed === true) ? d
                                    : this.width;
                            a = (a !== undefined || this.collapsed === true) ? a
                                    : this.height;
                            if (b) {
                                this.width = d;
                                this.height = a
                            }
                            c.layout(d, a)
                        }
                        return this
                    },
                    setComponentLayout : function(b) {
                        var a = this.componentLayout;
                        if (a && a.isLayout && a != b) {
                            a.setOwner(null)
                        }
                        this.componentLayout = b;
                        b.setOwner(this)
                    },
                    getComponentLayout : function() {
                        if (!this.componentLayout
                                || !this.componentLayout.isLayout) {
                            this.setComponentLayout(Ext.layout.LayoutManager
                                    .create(this.componentLayout,
                                            "autocomponent"))
                        }
                        return this.componentLayout
                    },
                    afterComponentLayout : Ext.emptyFn,
                    setPosition : function(a, b) {
                        if (Ext.isObject(a)) {
                            b = a.y;
                            a = a.x
                        }
                        if (!this.rendered) {
                            return this
                        }
                        if (a !== undefined || b !== undefined) {
                            this.el.setBox(a, b);
                            this.onPosition(a, b);
                            this.fireEvent("move", this, a, b)
                        }
                        return this
                    },
                    onPosition : Ext.emptyFn,
                    setWidth : function(a) {
                        return this.setSize(a)
                    },
                    setHeight : function(a) {
                        return this.setSize(undefined, a)
                    },
                    getSize : function() {
                        return this.el.getSize()
                    },
                    getWidth : function() {
                        return this.el.getWidth()
                    },
                    getHeight : function() {
                        return this.el.getHeight()
                    },
                    setLoading : function(a, b) {
                        if (this.rendered) {
                            if (a) {
                                this.loadMask = this.loadMask
                                        || new Ext.LoadMask(b ? this
                                                .getTargetEl() : this.el, Ext
                                                .applyIf(Ext.isObject(a) ? a
                                                        : {}));
                                this.loadMask.show()
                            } else {
                                Ext.destroy(this.loadMask);
                                this.loadMask = null
                            }
                        }
                        return this.loadMask
                    },
                    setDocked : function(a, b) {
                        this.dock = a;
                        if (b && this.ownerCt && this.rendered) {
                            this.ownerCt.doComponentLayout()
                        }
                        return this
                    },
                    onDestroy : function() {
                        if (this.monitorResize && Ext.EventManager.resizeEvent) {
                            Ext.EventManager.resizeEvent.removeListener(
                                    this.setSize, this)
                        }
                        Ext.destroy(this.componentLayout, this.loadMask)
                    },
                    destroy : function() {
                        if (!this.isDestroyed) {
                            if (this.fireEvent("beforedestroy", this) !== false) {
                                this.destroying = true;
                                this.beforeDestroy();
                                if (this.ownerCt && this.ownerCt.remove) {
                                    this.ownerCt.remove(this, false)
                                }
                                if (this.rendered) {
                                    this.el.remove()
                                }
                                this.onDestroy();
                                Ext.ComponentMgr.unregister(this);
                                this.fireEvent("destroy", this);
                                this.clearListeners();
                                this.destroying = false;
                                this.isDestroyed = true
                            }
                        }
                    }
                });
Ext.lib.Component.prototype.on = Ext.lib.Component.prototype.addListener;
Ext.lib.Component.prototype.prev = Ext.lib.Component.prototype.previousSibling;
Ext.lib.Component.prototype.next = Ext.lib.Component.prototype.nextSibling;
Ext.lib.Component.AUTO_ID = 1000;
Ext.Component = Ext.extend(Ext.lib.Component, {});
Ext.reg("component", Ext.Component);
Ext.Component = Ext
        .extend(
                Ext.lib.Component,
                {
                    showAnimation : null,
                    monitorOrientation : false,
                    floatingCls : "x-floating",
                    hideOnMaskTap : true,
                    stopMaskTapEvent : true,
                    centered : false,
                    modal : false,
                    fullscreen : false,
                    layoutOnOrientationChange : null,
                    initComponent : function() {
                        this.addEvents("beforeorientationchange",
                                "orientationchange");
                        if (this.fullscreen || this.floating) {
                            this.monitorOrientation = true;
                            this.autoRender = true
                        }
                        if (this.fullscreen) {
                            var a = Ext.Viewport.getSize();
                            this.width = a.width;
                            this.height = a.height;
                            this.cls = (this.cls || "") + " x-fullscreen";
                            this.renderTo = document.body
                        }
                    },
                    onRender : function() {
                        Ext.Component.superclass.onRender
                                .apply(this, arguments);
                        if (this.monitorOrientation) {
                            this.el.addCls("x-" + Ext.Viewport.orientation)
                        }
                        if (this.floating) {
                            this.setFloating(true)
                        }
                        if (this.draggable) {
                            this.setDraggable(this.draggable)
                        }
                        if (this.scroll) {
                            this.setScrollable(this.scroll)
                        }
                    },
                    afterRender : function() {
                        if (this.fullscreen) {
                            this.layoutOrientation(Ext.Viewport.orientation,
                                    this.width, this.height)
                        }
                        Ext.Component.superclass.afterRender.call(this)
                    },
                    initEvents : function() {
                        Ext.Component.superclass.initEvents.call(this);
                        if (this.monitorOrientation) {
                            Ext.EventManager.onOrientationChange(
                                    this.setOrientation, this)
                        }
                    },
                    afterComponentLayout : function() {
                        var c = this.scrollEl, a = this.scroller, b;
                        if (c) {
                            b = c.parent();
                            if (a.horizontal) {
                                c
                                        .setStyle("min-width", b.getWidth(true)
                                                + "px");
                                c.setHeight(b.getHeight(true) || null)
                            }
                            if (a.vertical) {
                                c.setStyle("min-height", b.getHeight(true)
                                        + "px");
                                c.setWidth(b.getWidth(true) || null)
                            }
                            a.updateBoundary(true)
                        }
                        if (this.fullscreen && Ext.is.iPad) {
                            Ext.repaint()
                        }
                    },
                    layoutOrientation : Ext.emptyFn,
                    update : function() {
                        Ext.Component.superclass.update.apply(this, arguments);
                        var a = this.scroller;
                        if (a && a.updateBoundary) {
                            a.updateBoundary(true)
                        }
                    },
                    show : function(a) {
                        var b = this.rendered;
                        if ((this.hidden || !b)
                                && this.fireEvent("beforeshow", this) !== false) {
                            if (this.anchorEl) {
                                this.anchorEl.hide()
                            }
                            if (!b && this.autoRender) {
                                this
                                        .render(Ext.isBoolean(this.autoRender) ? Ext
                                                .getBody()
                                                : this.autoRender)
                            }
                            this.hidden = false;
                            if (this.rendered) {
                                this.onShow(a);
                                this.fireEvent("show", this)
                            }
                        }
                        return this
                    },
                    showBy : function(b, c, d, a) {
                        if (!this.floating) {
                            return this
                        }
                        if (b.isComponent) {
                            b = b.el
                        } else {
                            b = Ext.get(b)
                        }
                        this.x = 0;
                        this.y = 0;
                        this.show(c);
                        if (a !== false) {
                            if (!this.anchorEl) {
                                this.anchorEl = this.el.createChild({
                                    cls : "x-anchor"
                                })
                            }
                            this.anchorEl.show()
                        }
                        this.alignTo(b, d, 20)
                    },
                    alignTo : function(f, e, g) {
                        var b = f.getPageBox(), q = {
                            width : window.innerWidth,
                            height : window.innerHeight
                        }, l = this.getSize(), a = {
                            width : Math.min(l.width, q.width),
                            height : Math.min(l.height, q.height)
                        }, s, j = 2, d = [ "tl-bl", "t-b", "tr-br", "l-r",
                                "l-r", "r-l", "bl-tl", "b-t", "br-tr" ], p = this.anchorEl, h = [
                                0, g ], i, c, k = false, n = [ 0, 0 ], o = b.left
                                + (b.width / 2), m = b.top + (b.height / 2);
                        if (o <= q.width * (1 / 3)) {
                            j = 1;
                            n[0] = 25
                        } else {
                            if (o >= q.width * (2 / 3)) {
                                j = 3;
                                n[0] = -30
                            }
                        }
                        if (m >= q.height * (2 / 3)) {
                            j += 6;
                            h = [ 0, -g ];
                            n[1] = -10
                        } else {
                            if (e !== false && m >= q.height * (1 / 3)) {
                                j += 3;
                                h = (j <= 5) ? [ g, 0 ] : [ -g, 0 ];
                                n = (j <= 5) ? [ 10, 0 ] : [ -10, 0 ];
                                k = true
                            } else {
                                n[1] = 10
                            }
                        }
                        s = d[j - 1];
                        i = this.el.getAlignToXY(f, s, h);
                        if (k) {
                            if (i[0] < 0) {
                                a.width = b.left - g
                            } else {
                                if (i[0] + a.width > q.width) {
                                    a.width = q.width - b.right - g
                                }
                            }
                        } else {
                            if (i[1] < 0) {
                                a.height = b.top - g
                            } else {
                                if (i[1] + a.height > q.height) {
                                    a.height = q.height - b.bottom - g
                                }
                            }
                        }
                        if (a.width != l.width) {
                            this.setSize(a.width)
                        } else {
                            if (a.height != l.height) {
                                this.setSize(undefined, a.height)
                            }
                        }
                        i = this.el.getAlignToXY(f, s, h);
                        this.setPosition(i[0], i[1]);
                        if (p) {
                            p.removeCls([ "x-anchor-bottom", "x-anchor-left",
                                    "x-anchor-right", "x-anchor-top" ]);
                            if (h[1] == g) {
                                c = "x-anchor-top"
                            } else {
                                if (h[1] == -g) {
                                    c = "x-anchor-bottom"
                                } else {
                                    if (h[0] == g) {
                                        c = "x-anchor-left"
                                    } else {
                                        c = "x-anchor-right"
                                    }
                                }
                            }
                            i = p.getAlignToXY(f, s, n);
                            p.setXY(i);
                            p.addCls(c)
                        }
                        return s
                    },
                    setCentered : function(b, d) {
                        this.centered = b;
                        if (this.rendered && d) {
                            var a, c;
                            if (!this.ownerCt) {
                                a = (Ext.Element.getViewportWidth() / 2)
                                        - (this.getWidth() / 2);
                                c = (Ext.Element.getViewportHeight() / 2)
                                        - (this.getHeight() / 2)
                            } else {
                                a = (this.ownerCt.getTargetEl().getWidth() / 2)
                                        - (this.getWidth() / 2);
                                c = (this.ownerCt.getTargetEl().getHeight() / 2)
                                        - (this.getHeight() / 2)
                            }
                            this.setPosition(a, c)
                        }
                        return this
                    },
                    hide : function(a) {
                        if (!this.hidden
                                && this.fireEvent("beforehide", this) !== false) {
                            this.hidden = true;
                            if (this.rendered) {
                                this.onHide(a, true)
                            }
                        }
                        return this
                    },
                    onShow : function(a) {
                        this.el.show();
                        Ext.Component.superclass.onShow.call(this, a);
                        if (a === undefined || a === true) {
                            a = this.showAnimation
                        }
                        if (this.floating) {
                            this.el.dom.parentNode
                                    || this.el.appendTo(document.body);
                            if (a) {
                                this.el.setStyle("opacity", 0.01)
                            }
                            if (this.centered) {
                                this.setCentered(true, true)
                            } else {
                                this.setPosition(this.x, this.y)
                            }
                            if (this.modal) {
                                this.el.parent().mask(null, "x-mask-gray")
                            }
                            if (this.hideOnMaskTap) {
                                Ext.getDoc().on("touchstart",
                                        this.onFloatingTouchStart, this, {
                                            capture : true,
                                            subsequent : true
                                        })
                            }
                        }
                        if (a) {
                            Ext.Anim.run(this, a, {
                                out : false,
                                autoClear : true
                            });
                            this.showAnimation = a
                        }
                    },
                    onFloatingTouchStart : function(a) {
                        if (!this.el.contains(a.target)) {
                            this.hide();
                            if (this.stopMaskTapEvent
                                    || Ext.fly(a.target).hasCls("x-mask")) {
                                a.stopEvent()
                            }
                        }
                    },
                    onHide : function(b, a) {
                        if (b === undefined || b === true) {
                            b = this.showAnimation
                        }
                        if (this.hideOnMaskTap && this.floating) {
                            Ext.getDoc().un("touchstart",
                                    this.onFloatingTouchStart, this, {
                                        capture : true,
                                        subsequent : true
                                    })
                        }
                        if (b) {
                            Ext.Anim.run(this, b, {
                                out : true,
                                reverse : true,
                                autoClear : true,
                                scope : this,
                                fireHideEvent : a,
                                after : this.doHide
                            })
                        } else {
                            this.doHide(null, {
                                fireHideEvent : a
                            })
                        }
                    },
                    doHide : function(c, a) {
                        var b = this.el.parent();
                        this.el.hide();
                        if (b && this.floating && this.modal) {
                            b.unmask()
                        }
                        if (a && a.fireHideEvent) {
                            this.fireEvent("hide", this)
                        }
                    },
                    setScrollable : function(a) {
                        var b = this, c;
                        if (!b.rendered) {
                            b.scroll = a;
                            return
                        }
                        Ext.destroy(b.scroller);
                        b.scroller = null;
                        if (b.originalGetTargetEl) {
                            b.getTargetEl = b.originalGetTargetEl
                        }
                        if (a !== false) {
                            c = Ext.isObject(a) ? a.direction : a;
                            a = Ext.apply({}, Ext.isObject(a) ? a : {}, {
                                direction : c
                            });
                            if (!b.scrollEl) {
                                b.scrollEl = b.getTargetEl().createChild()
                            }
                            b.originalGetTargetEl = b.getTargetEl;
                            b.getTargetEl = function() {
                                return b.scrollEl
                            };
                            b.scroller = (new Ext.util.ScrollView(b.scrollEl, a)).scroller
                        }
                    },
                    setFloating : function(b, a) {
                        this.floating = !!b;
                        this.hidden = true;
                        if (this.rendered) {
                            if (b !== false) {
                                this.el.addCls(this.floatingCls);
                                if (a) {
                                    this.show()
                                }
                            } else {
                                this.el.removeCls(this.floatingCls);
                                Ext.getDoc().un("touchstart",
                                        this.onFloatingTouchStart, this)
                            }
                        } else {
                            if (b !== false) {
                                if (this.layoutOnOrientationChange !== false) {
                                    this.layoutOnOrientationChange = true
                                }
                                this.autoRender = true
                            }
                        }
                    },
                    setDraggable : function(a, b) {
                        this.isDraggable = a;
                        if (this.rendered) {
                            if (a === false) {
                                if (this.dragObj) {
                                    this.dragObj.disable()
                                }
                            } else {
                                if (b) {
                                    this.show()
                                }
                                if (this.dragObj) {
                                    this.dragObj.enable()
                                } else {
                                    this.dragObj = new Ext.util.Draggable(
                                            this.el, Ext.apply({},
                                                    this.draggable || {}));
                                    this.relayEvents(this.dragObj, [
                                            "dragstart", "beforedragend",
                                            "drag", "dragend" ])
                                }
                            }
                        }
                    },
                    setOrientation : function(b, a, c) {
                        if (this.fireEvent("beforeorientationchange", this, b,
                                a, c) !== false) {
                            if (this.orientation != b) {
                                this.el.removeCls("x-" + this.orientation);
                                this.el.addCls("x-" + b)
                            }
                            this.orientation = b;
                            this.layoutOrientation(b, a, c);
                            if (this.fullscreen) {
                                this.setSize(a, c)
                            } else {
                                if (this.layoutOnOrientationChange) {
                                    this.doComponentLayout()
                                }
                            }
                            if (this.floating && this.centered) {
                                this.setCentered(true, true)
                            }
                            this.onOrientationChange(b, a, c);
                            this.fireEvent("orientationchange", this, b, a, c)
                        }
                    },
                    onOrientationChange : Ext.emptyFn,
                    beforeDestroy : function() {
                        if (this.floating && this.modal && !this.hidden) {
                            this.el.parent().unmask()
                        }
                        Ext.destroy(this.scroller);
                        Ext.Component.superclass.beforeDestroy.call(this)
                    },
                    onDestroy : function() {
                        if (this.monitorOrientation
                                && Ext.EventManager.orientationEvent) {
                            Ext.EventManager.orientationEvent.removeListener(
                                    this.setOrientation, this)
                        }
                        Ext.Component.superclass.onDestroy.call(this)
                    }
                });
Ext.BoxComponent = Ext.Component;
Ext.reg("component", Ext.Component);
Ext.reg("box", Ext.BoxComponent);
Ext.lib.Container = Ext
        .extend(
                Ext.Component,
                {
                    autoDestroy : true,
                    defaultType : "panel",
                    isContainer : true,
                    baseCls : "x-container",
                    bubbleEvents : [ "add", "remove" ],
                    initComponent : function() {
                        this.addEvents("afterlayout", "beforeadd",
                                "beforeremove", "add", "remove",
                                "beforecardswitch", "cardswitch");
                        this.layoutOnShow = new Ext.util.MixedCollection();
                        Ext.lib.Container.superclass.initComponent.call(this);
                        this.initItems()
                    },
                    initItems : function() {
                        var a = this.items;
                        this.items = new Ext.util.MixedCollection(false,
                                this.getComponentId);
                        if (a) {
                            if (!Ext.isArray(a)) {
                                a = [ a ]
                            }
                            this.add(a)
                        }
                    },
                    afterRender : function() {
                        this.getLayout();
                        Ext.lib.Container.superclass.afterRender.apply(this,
                                arguments)
                    },
                    setLayout : function(b) {
                        var a = this.layout;
                        if (a && a.isLayout && a != b) {
                            a.setOwner(null)
                        }
                        this.layout = b;
                        b.setOwner(this)
                    },
                    getLayout : function() {
                        if (!this.layout || !this.layout.isLayout) {
                            this.setLayout(Ext.layout.LayoutManager.create(
                                    this.layout, "autocontainer"))
                        }
                        return this.layout
                    },
                    doLayout : function() {
                        var a = this.getLayout();
                        if (this.rendered && a) {
                            a.layout()
                        }
                        return this
                    },
                    afterLayout : function(a) {
                        this.fireEvent("afterlayout", this, a)
                    },
                    prepareItems : function(a, c) {
                        if (!Ext.isArray(a)) {
                            a = [ a ]
                        }
                        var e, b, d;
                        for (b = 0, d = a.length; b < d; b++) {
                            e = a[b];
                            if (c) {
                                e = this.applyDefaults(e)
                            }
                            a[b] = this.lookupComponent(e)
                        }
                        return a
                    },
                    applyDefaults : function(a) {
                        var b = this.defaults;
                        if (b) {
                            if (Ext.isFunction(b)) {
                                b = b.call(this, a)
                            }
                            if (Ext.isString(a)) {
                                a = Ext.ComponentMgr.get(a);
                                Ext.apply(a, b)
                            } else {
                                if (!a.isComponent) {
                                    Ext.applyIf(a, b)
                                } else {
                                    Ext.apply(a, b)
                                }
                            }
                        }
                        return a
                    },
                    lookupComponent : function(a) {
                        if (Ext.isString(a)) {
                            return Ext.ComponentMgr.get(a)
                        } else {
                            return this.createComponent(a)
                        }
                        return a
                    },
                    createComponent : function(a, b) {
                        if (a.isComponent) {
                            return a
                        }
                        return Ext.create(a, b || this.defaultType)
                    },
                    getComponentId : function(a) {
                        return a.getItemId()
                    },
                    add : function() {
                        var f = Array.prototype.slice.call(arguments), d = -1;
                        if (typeof f[0] == "number") {
                            d = f.shift()
                        }
                        var a = f.length > 1;
                        if (a || Ext.isArray(f[0])) {
                            var g = a ? f : f[0], b = [], c, e, j;
                            for (c = 0, e = g.length; c < e; c++) {
                                j = g[c];
                                if (!j) {
                                    throw "Trying to add a null item as a child of Container with itemId/id: "
                                            + this.getItemId()
                                }
                                if (d != -1) {
                                    j = this.add(d + c, j)
                                } else {
                                    j = this.add(j)
                                }
                                b.push(j)
                            }
                            return b
                        }
                        var h = this.prepareItems(f[0], true)[0];
                        d = (d !== -1) ? d : this.items.length;
                        if (this.fireEvent("beforeadd", this, h, d) !== false
                                && this.onBeforeAdd(h) !== false) {
                            this.items.insert(d, h);
                            h.onAdded(this, d);
                            this.onAdd(h, d);
                            this.fireEvent("add", this, h, d)
                        }
                        return h
                    },
                    onAdd : Ext.emptyFn,
                    onRemove : Ext.emptyFn,
                    insert : function(b, a) {
                        return this.add(b, a)
                    },
                    onBeforeAdd : function(a) {
                        if (a.ownerCt) {
                            a.ownerCt.remove(a, false)
                        }
                        if (this.hideBorders === true) {
                            a.border = (a.border === true)
                        }
                    },
                    remove : function(a, b) {
                        var d = this.getComponent(a);
                        if (!d) {
                            console
                                    .warn("Attempted to remove a component that does not exist. Ext.Container: remove takes an argument of the component to remove. cmp.remove() is incorrect usage.")
                        }
                        if (d
                                && this.fireEvent("beforeremove", this, d) !== false) {
                            this.doRemove(d, b);
                            this.fireEvent("remove", this, d)
                        }
                        return d
                    },
                    doRemove : function(c, b) {
                        var d = this.layout, a = d && this.rendered;
                        this.items.remove(c);
                        c.onRemoved();
                        if (a) {
                            d.onRemove(c)
                        }
                        this.onRemove(c, b);
                        if (b === true || (b !== false && this.autoDestroy)) {
                            c.destroy()
                        }
                        if (a && !b) {
                            d.afterRemove(c)
                        }
                    },
                    removeAll : function(b) {
                        var f, d = this.items.items.slice(), a = [], e = d.length, c;
                        for (c = 0; c < e; c++) {
                            f = d[c];
                            this.remove(f, b);
                            if (f.ownerCt !== this) {
                                a.push(f)
                            }
                        }
                        return a
                    },
                    getRefItems : function(a) {
                        var b = this.items.items.slice(), e = b.length, c, d;
                        if (a) {
                            for (c = 0; c < e; c++) {
                                d = b[c];
                                if (d.getRefItems) {
                                    b = b.concat(d.getRefItems(true))
                                }
                            }
                        }
                        return b
                    },
                    getComponent : function(a) {
                        if (Ext.isObject(a)) {
                            a = a.getItemId()
                        }
                        return this.items.get(a)
                    },
                    query : function(a) {
                        return Ext.ComponentQuery.query(a, this)
                    },
                    child : function(a) {
                        return this.query("> " + a)[0] || null
                    },
                    down : function(a) {
                        return this.query(a)[0] || null
                    },
                    show : function() {
                        Ext.lib.Container.superclass.show
                                .apply(this, arguments);
                        var e = this.layoutOnShow, d = e.getCount(), b = 0, a, c;
                        for (; b < d; b++) {
                            c = e.get(b);
                            a = c.needsLayout;
                            if (Ext.isObject(a)) {
                                c.doComponentLayout(a.width, a.height,
                                        a.isSetSize)
                            }
                        }
                        e.clear()
                    },
                    beforeDestroy : function() {
                        var a = this.items, b;
                        if (a) {
                            while ((b = a.first())) {
                                this.doRemove(b, true)
                            }
                        }
                        Ext.destroy(this.layout);
                        Ext.lib.Container.superclass.beforeDestroy.call(this)
                    }
                });
Ext.Container = Ext.extend(Ext.lib.Container, {});
Ext.reg("container", Ext.Container);
Ext.Container = Ext
        .extend(
                Ext.lib.Container,
                {
                    cardSwitchAnimation : null,
                    initComponent : function() {
                        if (this.scroll) {
                            this.fields = new Ext.util.MixedCollection();
                            if (!Ext.is.Blackberry) {
                                this.fields.on({
                                    add : this.onFieldAdd,
                                    remove : this.onFieldRemove,
                                    scope : this
                                })
                            }
                            this.on({
                                add : this.onItemAdd,
                                remove : this.onItemRemove,
                                scope : this
                            })
                        }
                        Ext.Container.superclass.initComponent.apply(this,
                                arguments)
                    },
                    afterRender : function() {
                        Ext.Container.superclass.afterRender.apply(this,
                                arguments);
                        if (this.scroller) {
                            if ((Ext.is.Android) && this.containsFormFields) {
                                this.scroller.setUseCssTransform(false)
                            }
                            this.scroller.on("scrollstart",
                                    this.onFieldScrollStart, this)
                        }
                    },
                    onFieldScrollStart : function() {
                        var a = this.focusedField;
                        if (a && Ext.is.iOS) {
                            a.blur()
                        }
                    },
                    onItemAdd : function(b, a) {
                        this.fields.addAll(Ext.ComponentQuery.query(
                                "[isField]", a))
                    },
                    onItemRemove : function(b, a) {
                        this.fields.removeAll(Ext.ComponentQuery.query(
                                "[isField]", a))
                    },
                    onFieldAdd : function(a, b) {
                        this.handleFieldEventListener(true, b)
                    },
                    onFieldRemove : function(a, b) {
                        this.handleFieldEventListener(false, b)
                    },
                    handleFieldEventListener : function(b, a) {
                        if (!this.fieldEventWrap) {
                            this.fieldEventWrap = {}
                        }
                        if ([ "textfield", "passwordfield", "emailfield",
                                "textareafield", "searchfield", "urlfield",
                                "numberfield", "spinnerfield" ]
                                .indexOf(a.xtype) !== -1) {
                            if (b) {
                                this.fieldEventWrap[a.id] = {
                                    beforefocus : function(c) {
                                        this.onFieldBeforeFocus(a, c)
                                    },
                                    focus : function(c) {
                                        this.onFieldFocus(a, c)
                                    },
                                    blur : function(c) {
                                        this.onFieldBlur(a, c)
                                    },
                                    keyup : function(c) {
                                        this.onFieldKeyUp(a, c)
                                    },
                                    scope : this
                                };
                                this.containsFormFields = true
                            }
                            a[b ? "on" : "un"](this.fieldEventWrap[a.id]);
                            if (!b) {
                                delete this.fieldEventWrap[a.id]
                            }
                        }
                    },
                    onFieldKeyUp : function(b, a) {
                        if (Ext.is.iOS || Ext.is.Desktop) {
                            this.resetLastWindowScroll()
                        }
                    },
                    onFieldBeforeFocus : function(b, a) {
                        this.focusingField = b
                    },
                    getLastWindowScroll : function() {
                        if (!this.lastWindowScroll) {
                            this.resetLastWindowScroll()
                        }
                        return {
                            x : this.lastWindowScroll.x,
                            y : this.lastWindowScroll.y
                        }
                    },
                    resetLastWindowScroll : function() {
                        this.lastWindowScroll = {
                            x : window.pageXOffset,
                            y : window.pageYOffset
                        }
                    },
                    adjustScroller : function(b) {
                        var a = this.getClosestScroller(), c = this
                                .getLastWindowScroll();
                        a.setOffset(b);
                        if (Ext.is.iOS) {
                            window.scrollTo(c.x, c.y)
                        }
                        this.resetLastWindowScroll()
                    },
                    onFieldFocus : function(h, g) {
                        if (!Ext.is.iOS && !Ext.is.Desktop) {
                            var b = h.fieldEl.dom;
                            if (b.scrollIntoViewIfNeeded) {
                                b.scrollIntoViewIfNeeded(true)
                            }
                        } else {
                            var f = this.getClosestScroller(), i = Ext.util.Region
                                    .from(f.containerBox), l = h.fieldEl
                                    .getPageBox(true);
                            if (this.focusingField == h || !Ext.is.iOS) {
                                if (Ext.is.iOS && window.pageYOffset == 0) {
                                    window.scrollTo(0, 0)
                                }
                                var j = new Ext.util.Offset();
                                if (l.left < i.left) {
                                    j.x = i.left - l.left
                                }
                                if (l.top < i.top) {
                                    j.y = i.top - l.top
                                }
                                if (!j.isZero()) {
                                    var k = this.getLastWindowScroll();
                                    f.scrollBy(j);
                                    if (Ext.is.iOS) {
                                        window.scrollTo(k.x, k.y)
                                    }
                                    this.resetLastWindowScroll()
                                }
                            } else {
                                if (this.lastFocusedField) {
                                    var a = l.top
                                            - this.lastFocusedField.fieldEl
                                                    .getY(), c = f.offset.y - a, d = false;
                                    if (!i.contains(l)
                                            && (c != 0 || (c == 0 && f.offset.y != 0))) {
                                        d = true
                                    }
                                    if (c > 0) {
                                        c = 0
                                    }
                                    if (d) {
                                        this
                                                .adjustScroller(new Ext.util.Offset(
                                                        f.offset.x, c))
                                    }
                                }
                            }
                            this.resetLastWindowScroll()
                        }
                        this.lastFocusedField = h;
                        this.focusedField = h;
                        this.focusingField = null
                    },
                    getClosestScroller : function() {
                        if (!this.closestScroller) {
                            this.closestScroller = this.scroller
                                    || this.el.getScrollParent()
                        }
                        return this.closestScroller
                    },
                    onFieldBlur : function(b, a) {
                        if (this.focusingField == b) {
                            this.focusingField = null
                        }
                        if (this.focusedField == b) {
                            this.focusedField = null
                        }
                    },
                    afterLayout : function(a) {
                        if (this.floating && this.centered) {
                            this.setCentered(true, true)
                        }
                        if (this.scroller) {
                            this.scroller.updateBoundary()
                        }
                        Ext.Container.superclass.afterLayout.call(this, a)
                    },
                    getActiveItem : function() {
                        if (this.layout && this.layout.type == "card") {
                            return this.layout.activeItem
                        } else {
                            return null
                        }
                    },
                    setActiveItem : function(a, b) {
                        this.layout.setActiveItem(a, b);
                        return this
                    },
                    onBeforeCardSwitch : function(a, c, b, d) {
                        return this.fireEvent("beforecardswitch", this, a, c,
                                b, d)
                    },
                    onCardSwitch : function(a, c, b, d) {
                        return this.fireEvent("cardswitch", this, a, c, b, d)
                    },
                    disable : function() {
                        Ext.Container.superclass.disable.call(this);
                        this.el.mask(null, "x-mask-gray")
                    },
                    enable : function() {
                        Ext.Container.superclass.enable.call(this);
                        this.el.unmask()
                    }
                });
Ext.reg("container", Ext.Container);
Ext.lib.Panel = Ext
        .extend(
                Ext.Container,
                {
                    baseCls : "x-panel",
                    isPanel : true,
                    componentLayout : "dock",
                    renderTpl : [ '<div class="{baseCls}-body<tpl if="bodyCls"> {bodyCls}</tpl>"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>></div>' ],
                    initComponent : function() {
                        this.addEvents("bodyresize");
                        Ext.applyIf(this.renderSelectors, {
                            body : "." + this.baseCls + "-body"
                        });
                        Ext.lib.Panel.superclass.initComponent.call(this)
                    },
                    initItems : function() {
                        Ext.lib.Panel.superclass.initItems.call(this);
                        var a = this.dockedItems;
                        this.dockedItems = new Ext.util.MixedCollection(false,
                                this.getComponentId);
                        if (a) {
                            this.addDocked(a)
                        }
                    },
                    getDockedComponent : function(a) {
                        if (Ext.isObject(a)) {
                            a = a.getItemId()
                        }
                        return this.dockedItems.get(a)
                    },
                    getComponent : function(a) {
                        var b = Ext.lib.Panel.superclass.getComponent.call(
                                this, a);
                        if (b == undefined) {
                            b = this.getDockedComponent(a)
                        }
                        return b
                    },
                    initBodyStyles : function() {
                        var a = Ext.isString(this.bodyStyle) ? this.bodyStyle
                                .split(";") : [], b = Ext.Element;
                        if (this.bodyPadding != undefined) {
                            a
                                    .push("padding: "
                                            + b
                                                    .unitizeBox((this.bodyPadding === true) ? 5
                                                            : this.bodyPadding))
                        }
                        if (this.bodyMargin != undefined) {
                            a
                                    .push("margin: "
                                            + b
                                                    .unitizeBox((this.bodyMargin === true) ? 5
                                                            : this.bodyMargin))
                        }
                        if (this.bodyBorder != undefined) {
                            a
                                    .push("border-width: "
                                            + b
                                                    .unitizeBox((this.bodyBorder === true) ? 1
                                                            : this.bodyBorder))
                        }
                        delete this.bodyStyle;
                        return a.length ? a.join(";") : undefined
                    },
                    initRenderData : function() {
                        return Ext.applyIf(
                                Ext.lib.Panel.superclass.initRenderData
                                        .call(this), {
                                    bodyStyle : this.initBodyStyles(),
                                    bodyCls : this.bodyCls
                                })
                    },
                    addDocked : function(a, e) {
                        a = this.prepareItems(a);
                        var d, b, c;
                        for (b = 0, c = a.length; b < c; b++) {
                            d = a[b];
                            d.dock = d.dock || "top";
                            if (e !== undefined) {
                                this.dockedItems.insert(e + b, d)
                            } else {
                                this.dockedItems.add(d)
                            }
                            d.onAdded(this, b);
                            this.onDockedAdd(d)
                        }
                        if (this.rendered) {
                            this.doComponentLayout()
                        }
                    },
                    onDockedAdd : Ext.emptyFn,
                    onDockedRemove : Ext.emptyFn,
                    insertDocked : function(b, a) {
                        this.addDocked(a, b)
                    },
                    removeDocked : function(d, b) {
                        if (!this.dockedItems.contains(d)) {
                            return d
                        }
                        var c = this.componentLayout, a = c && this.rendered;
                        if (a) {
                            c.onRemove(d)
                        }
                        this.dockedItems.remove(d);
                        d.onRemoved();
                        this.onDockedRemove(d);
                        if (b === true || (b !== false && this.autoDestroy)) {
                            d.destroy()
                        }
                        if (a && !b) {
                            c.afterRemove(d)
                        }
                        this.doComponentLayout();
                        return d
                    },
                    getDockedItems : function() {
                        if (this.dockedItems && this.dockedItems.items.length) {
                            return this.dockedItems.items.slice()
                        }
                        return []
                    },
                    getTargetEl : function() {
                        return this.body
                    },
                    getRefItems : function(a) {
                        var f = Ext.lib.Panel.superclass.getRefItems.call(this,
                                a), c = this.getDockedItems(), e = c.length, b = 0, d;
                        f = f.concat(c);
                        if (a) {
                            for (; b < e; b++) {
                                d = c[b];
                                if (d.getRefItems) {
                                    f = f.concat(d.getRefItems(true))
                                }
                            }
                        }
                        return f
                    },
                    beforeDestroy : function() {
                        var b = this.dockedItems, a;
                        if (b) {
                            while ((a = b.first())) {
                                this.removeDocked(a, true)
                            }
                        }
                        Ext.lib.Panel.superclass.beforeDestroy.call(this)
                    }
                });
Ext.Panel = Ext.extend(Ext.lib.Panel, {});
Ext.reg("panel", Ext.Panel);
Ext.Panel = Ext.extend(Ext.lib.Panel, {
    scroll : false
});
Ext.reg("panel", Ext.Panel);
Ext.Button = Ext.extend(Ext.Component, {
    initComponent : function() {
        this.addEvents("tap", "beforetap");
        Ext.Button.superclass.initComponent.call(this);
        this.createAutoHandler()
    },
    iconAlign : "left",
    baseCls : "x-button",
    pressedCls : "x-button-pressed",
    badgeText : "",
    badgeCls : "x-badge",
    hasBadgeCls : "x-hasbadge",
    labelCls : "x-button-label",
    ui : "normal",
    isButton : true,
    pressedDelay : 0,
    iconMaskCls : "x-icon-mask",
    iconMask : false,
    afterRender : function(c, a) {
        var e = this;
        Ext.Button.superclass.afterRender.call(e, c, a);
        var g = e.text, d = e.icon, b = e.iconCls, f = e.badgeText;
        e.text = e.icon = e.iconCls = e.badgeText = null;
        e.setText(g);
        e.setIcon(d);
        e.setIconClass(b);
        if (e.iconMask && e.iconEl) {
            e.iconEl.addCls(e.iconMaskCls)
        }
        e.setBadge(f)
    },
    initEvents : function() {
        var a = this;
        Ext.Button.superclass.initEvents.call(a);
        a.mon(a.el, {
            scope : a,
            tap : a.onPress,
            tapstart : a.onTapStart,
            tapcancel : a.onTapCancel
        })
    },
    onTapStart : function() {
        var a = this;
        if (!a.disabled) {
            if (a.pressedDelay) {
                a.pressedTimeout = setTimeout(function() {
                    a.el.addCls(a.pressedCls)
                }, Ext.isNumber(a.pressedDelay) ? a.pressedDelay : 100)
            } else {
                a.el.addCls(a.pressedCls)
            }
        }
    },
    onTapCancel : function() {
        var a = this;
        if (a.pressedTimeout) {
            clearTimeout(a.pressedTimeout);
            delete a.pressedTimeout
        }
        a.el.removeCls(a.pressedCls)
    },
    setHandler : function(b, a) {
        this.handler = b;
        this.scope = a;
        return this
    },
    setText : function(b) {
        var a = this;
        if (a.rendered) {
            if (!a.textEl && b) {
                a.textEl = a.el.createChild({
                    tag : "span",
                    html : b,
                    cls : this.labelCls
                })
            } else {
                if (a.textEl && b != a.text) {
                    if (b) {
                        a.textEl.setHTML(b)
                    } else {
                        a.textEl.remove();
                        a.textEl = null
                    }
                }
            }
        }
        a.text = b;
        return a
    },
    setIcon : function(a) {
        var b = this;
        if (b.rendered) {
            if (!b.iconEl && a) {
                b.iconEl = b.el.createChild({
                    tag : "img",
                    src : Ext.BLANK_IMAGE_URL,
                    style : "background-image: " + (a ? "url(" + a + ")" : "")
                });
                b.setIconAlign(b.iconAlign)
            } else {
                if (b.iconEl && a != b.icon) {
                    if (a) {
                        b.iconEl.setStyle("background-image", a ? "url(" + a
                                + ")" : "");
                        b.setIconAlign(b.iconAlign)
                    } else {
                        b.setIconAlign(false);
                        b.iconEl.remove();
                        b.iconEl = null
                    }
                }
            }
        }
        b.icon = a;
        return b
    },
    setIconClass : function(a) {
        var b = this;
        if (b.rendered) {
            if (!b.iconEl && a) {
                b.iconEl = b.el.createChild({
                    tag : "img",
                    src : Ext.BLANK_IMAGE_URL,
                    cls : a
                });
                b.setIconAlign(b.iconAlign)
            } else {
                if (b.iconEl && a != b.iconCls) {
                    if (a) {
                        if (b.iconCls) {
                            b.iconEl.removeCls(b.iconCls)
                        }
                        b.iconEl.addCls(a);
                        b.setIconAlign(b.iconAlign)
                    } else {
                        b.setIconAlign(false);
                        b.iconEl.remove();
                        b.iconEl = null
                    }
                }
            }
        }
        b.iconCls = a;
        return b
    },
    setIconAlign : function(d) {
        var c = this, a = [ "top", "right", "bottom", "left" ], d = ((a
                .indexOf(d) == -1 || !d) && d !== false) ? c.iconAlign : d, b;
        if (c.rendered && c.iconEl) {
            c.el.removeCls("x-iconalign-" + c.iconAlign);
            if (d) {
                c.el.addCls("x-iconalign-" + d)
            }
        }
        c.iconAlign = (d === false) ? c.iconAlign : d;
        return c
    },
    setBadge : function(b) {
        var a = this;
        if (a.rendered) {
            if (!a.badgeEl && b) {
                a.badgeEl = a.el.createChild({
                    tag : "span",
                    cls : a.badgeCls,
                    html : b
                });
                a.el.addCls(a.hasBadgeCls)
            } else {
                if (a.badgeEl && b != a.badgeText) {
                    if (b) {
                        a.badgeEl.setHTML(b);
                        a.el.addCls(a.hasBadgeCls)
                    } else {
                        a.badgeEl.remove();
                        a.badgeEl = null;
                        a.el.removeCls(a.hasBadgeCls)
                    }
                }
            }
        }
        a.badgeText = b;
        return a
    },
    getText : function() {
        return this.text
    },
    getBadgeText : function() {
        return this.badgeText
    },
    onDisable : function() {
        this.onDisableChange(true)
    },
    onEnable : function() {
        this.onDisableChange(false)
    },
    onDisableChange : function(a) {
        var b = this;
        if (b.el) {
            b.el[a ? "addCls" : "removeCls"](b.disabledCls);
            b.el.dom.disabled = a
        }
        b.disabled = a
    },
    onPress : function(b) {
        var a = this;
        if (!a.disabled && this.fireEvent("beforetap") !== false) {
            setTimeout(function() {
                if (!a.preventCancel) {
                    a.onTapCancel()
                }
                a.callHandler(b);
                a.fireEvent("tap", a, b)
            }, 10)
        }
    },
    callHandler : function(b) {
        var a = this;
        if (a.handler) {
            a.handler.call(a.scope || a, a, b)
        }
    },
    createAutoHandler : function() {
        var a = this, b = a.autoEvent;
        if (b) {
            if (typeof b == "string") {
                b = {
                    name : b,
                    scope : a.scope || a
                }
            }
            a.addEvents(b.name);
            a.setHandler(function() {
                b.scope.fireEvent(b.name, b.scope, a)
            }, b.scope)
        }
    }
});
Ext.reg("button", Ext.Button);
Ext.SegmentedButton = Ext.extend(Ext.Container, {
    defaultType : "button",
    componentCls : "x-segmentedbutton",
    pressedCls : "x-button-pressed",
    allowMultiple : false,
    initComponent : function() {
        this.layout = Ext.apply({}, this.layout || {}, {
            type : "hbox",
            align : "stretch"
        });
        Ext.SegmentedButton.superclass.initComponent.call(this);
        if (this.allowDepress === undefined) {
            this.allowDepress = this.allowMultiple
        }
        this.addEvents("toggle")
    },
    initEvents : function() {
        Ext.SegmentedButton.superclass.initEvents.call(this);
        this.mon(this.el, {
            tap : this.onTap,
            capture : true,
            scope : this
        })
    },
    afterLayout : function(b) {
        var a = this;
        Ext.SegmentedButton.superclass.afterLayout.call(a, b);
        if (!a.initialized) {
            a.items.each(function(d, c) {
                a.setPressed(d, !!d.pressed, true)
            });
            if (a.allowMultiple) {
                a.pressedButtons = a.getPressedButtons()
            }
            a.initialized = true
        }
    },
    onTap : function(b, a) {
        if (!this.disabled && (a = b.getTarget(".x-button"))) {
            this.setPressed(a.id, this.allowDepress ? undefined : true)
        }
    },
    getPressed : function() {
        return this.allowMultiple ? this.getPressedButtons()
                : this.pressedButton
    },
    setPressed : function(a, d, b) {
        var c = this;
        a = c.getComponent(a);
        if (!a || !a.isButton || a.disabled) {
            if (!c.allowMultiple && c.pressedButton) {
                c.setPressed(c.pressedButton, false)
            }
            return
        }
        if (!Ext.isBoolean(d)) {
            d = !a.pressed
        }
        if (d) {
            if (!c.allowMultiple) {
                if (c.pressedButton && c.pressedButton !== a) {
                    c.pressedButton.el.removeCls(c.pressedCls);
                    c.pressedButton.pressed = false;
                    if (b !== true) {
                        c.fireEvent("toggle", c, c.pressedButton, false)
                    }
                }
                c.pressedButton = a
            }
            a.el.addCls(c.pressedCls);
            a.pressed = true;
            a.preventCancel = true;
            if (c.initialized && b !== true) {
                c.fireEvent("toggle", c, a, true)
            }
        } else {
            if (!d) {
                if (!c.allowMultiple && a === c.pressedButton) {
                    c.pressedButton = null
                }
                if (a.pressed) {
                    a.el.removeCls(c.pressedCls);
                    a.pressed = false;
                    if (b !== true) {
                        c.fireEvent("toggle", c, a, false)
                    }
                }
            }
        }
        if (c.allowMultiple && c.initialized) {
            c.pressedButtons = c.getPressedButtons()
        }
    },
    getPressedButtons : function(b) {
        var a = this.items.filterBy(function(c) {
            return c.isButton && !c.disabled && c.pressed
        });
        return a.items
    },
    disable : function() {
        this.items.each(function(a) {
            a.disable()
        });
        Ext.SegmentedButton.superclass.disable.apply(this, arguments)
    },
    enable : function() {
        this.items.each(function(a) {
            a.enable()
        }, this);
        Ext.SegmentedButton.superclass.enable.apply(this, arguments)
    }
});
Ext.reg("segmentedbutton", Ext.SegmentedButton);
Ext.AbstractStoreSelectionModel = Ext
        .extend(
                Ext.util.Observable,
                {
                    allowDeselect : false,
                    selected : null,
                    constructor : function(a) {
                        a = a || {};
                        Ext.apply(this, a);
                        this.modes = {
                            SINGLE : true,
                            SIMPLE : true,
                            MULTI : true
                        };
                        this.setSelectionMode(a.mode);
                        this.selected = new Ext.util.MixedCollection();
                        Ext.AbstractStoreSelectionModel.superclass.constructor
                                .call(this, a)
                    },
                    bind : function(a, b) {
                        if (!b && this.store) {
                            if (a !== this.store && this.store.autoDestroy) {
                                this.store.destroy()
                            } else {
                                this.store.un("add", this.onStoreAdd, this);
                                this.store.un("clear", this.onStoreClear, this);
                                this.store.un("remove", this.onStoreRemove,
                                        this);
                                this.store.un("update", this.onStoreUpdate,
                                        this)
                            }
                        }
                        if (a) {
                            a = Ext.StoreMgr.lookup(a);
                            a.on({
                                add : this.onStoreAdd,
                                clear : this.onStoreClear,
                                remove : this.onStoreRemove,
                                update : this.onStoreUpdate,
                                scope : this
                            })
                        }
                        this.store = a;
                        if (a && !b) {
                            this.refresh()
                        }
                    },
                    selectAll : function(a) {
                        var c = this.store.getRange();
                        for ( var b = 0, d = c.length; b < d; b++) {
                            this.doSelect(c[b], true, a)
                        }
                    },
                    deselectAll : function() {
                        var b = this.getSelection();
                        for ( var a = 0, c = b.length; a < c; a++) {
                            this.doDeselect(b[a])
                        }
                    },
                    selectWithEvent : function(a, b) {
                        switch (this.selectionMode) {
                        case "MULTI":
                            if (b.ctrlKey && this.isSelected(a)) {
                                this.doDeselect(a, false)
                            } else {
                                if (b.shiftKey && this.lastFocused) {
                                    this.selectRange(this.lastFocused, a,
                                            b.ctrlKey)
                                } else {
                                    if (b.ctrlKey) {
                                        this.doSelect(a, true, false)
                                    } else {
                                        if (this.isSelected(a) && !b.shiftKey
                                                && !b.ctrlKey
                                                && this.selected.getCount() > 1) {
                                            this.doSelect(a, false, false)
                                        } else {
                                            this.doSelect(a, false)
                                        }
                                    }
                                }
                            }
                            break;
                        case "SIMPLE":
                            if (this.isSelected(a)) {
                                this.doDeselect(a)
                            } else {
                                this.doSelect(a, true)
                            }
                            break;
                        case "SINGLE":
                            if (this.allowDeselect && this.isSelected(a)) {
                                this.doDeselect(a)
                            } else {
                                this.doSelect(a, false)
                            }
                            break
                        }
                    },
                    selectRange : function(g, h, k, b) {
                        var e, j = this.store.indexOf(g), d = this.store
                                .indexOf(h), f, c = 0, a;
                        if (this.isLocked()) {
                            return
                        }
                        if (j > d) {
                            f = d;
                            d = j;
                            j = f
                        }
                        for (e = j; e <= d; e++) {
                            if (this.isSelected(this.store.getAt(e))) {
                                c++
                            }
                        }
                        if (!b) {
                            a = -1
                        } else {
                            a = (b == "up") ? j : d
                        }
                        for (e = j; e <= d; e++) {
                            if (c == (d - j + 1)) {
                                if (e != a) {
                                    this.doDeselect(e, true)
                                }
                            } else {
                                this.doSelect(e, true)
                            }
                        }
                    },
                    select : function(b, c, a) {
                        this.doSelect(b, c, a)
                    },
                    deselect : function(b, a) {
                        this.doDeselect(b, a)
                    },
                    doSelect : function(c, d, b) {
                        if (this.locked) {
                            return
                        }
                        if (typeof c === "number") {
                            c = [ this.store.getAt(c) ]
                        }
                        if (this.selectionMode == "SINGLE" && c) {
                            var a = c.length ? c[0] : c;
                            this.doSingleSelect(a, b)
                        } else {
                            this.doMultiSelect(c, d, b)
                        }
                    },
                    doMultiSelect : function(c, g, b) {
                        if (this.locked) {
                            return
                        }
                        var e = this.selected, h = false, a;
                        c = !Ext.isArray(c) ? [ c ] : c;
                        if (!g && e.getCount() > 0) {
                            h = true;
                            this.doDeselect(this.getSelection(), true)
                        }
                        for ( var d = 0, f = c.length; d < f; d++) {
                            a = c[d];
                            if (g && this.isSelected(a)) {
                                continue
                            }
                            h = true;
                            this.lastSelected = a;
                            e.add(a);
                            if (!b) {
                                this.setLastFocused(a)
                            }
                            this.onSelectChange(a, true, b)
                        }
                        this.maybeFireSelectionChange(h && !b)
                    },
                    doDeselect : function(c, b) {
                        if (this.locked) {
                            return
                        }
                        if (typeof c === "number") {
                            c = [ this.store.getAt(c) ]
                        }
                        var g = false, e = this.selected, a;
                        c = !Ext.isArray(c) ? [ c ] : c;
                        for ( var d = 0, f = c.length; d < f; d++) {
                            a = c[d];
                            if (e.remove(a)) {
                                if (this.lastSelected == a) {
                                    this.lastSelected = e.last()
                                }
                                this.onSelectChange(a, false, b);
                                g = true
                            }
                        }
                        this.maybeFireSelectionChange(g && !b)
                    },
                    doSingleSelect : function(a, b) {
                        if (this.locked) {
                            return
                        }
                        if (this.isSelected(a)) {
                            return
                        }
                        var c = this.selected;
                        if (c.getCount() > 0) {
                            this.doDeselect(this.lastSelected, b)
                        }
                        c.add(a);
                        this.lastSelected = a;
                        this.onSelectChange(a, true, b);
                        this.setLastFocused(a);
                        this.maybeFireSelectionChange(!b)
                    },
                    setLastFocused : function(b) {
                        var a = this.lastFocused;
                        this.lastFocused = b;
                        this.onLastFocusChanged(a, b)
                    },
                    maybeFireSelectionChange : function(a) {
                        if (a) {
                            this.fireEvent("selectionchange", this, this
                                    .getSelection())
                        }
                    },
                    getLastSelected : function() {
                        return this.lastSelected
                    },
                    getLastFocused : function() {
                        return this.lastFocused
                    },
                    getSelection : function() {
                        return this.selected.getRange()
                    },
                    getSelectionMode : function() {
                        return this.selectionMode
                    },
                    setSelectionMode : function(a) {
                        a = a ? a.toUpperCase() : "SINGLE";
                        this.selectionMode = this.modes[a] ? a : "SINGLE"
                    },
                    isLocked : function() {
                        return this.locked
                    },
                    setLocked : function(a) {
                        this.locked = !!a
                    },
                    isSelected : function(a) {
                        a = Ext.isNumber(a) ? this.store.getAt(a) : a;
                        return this.selected.indexOf(a) !== -1
                    },
                    hasSelection : function() {
                        return this.selected.getCount() > 0
                    },
                    refresh : function() {
                        var a = [], e = this.getSelection(), d = e.length, c, f, b = 0;
                        for (; b < d; b++) {
                            c = e[b];
                            if (this.store.indexOf(c) != -1) {
                                a.push(c)
                            }
                        }
                        if (this.selected.getCount() != a.length) {
                            f = true
                        }
                        this.clearSelections();
                        if (a.length) {
                            this.doSelect(a, false, true)
                        }
                        this.maybeFireSelectionChange(f)
                    },
                    clearSelections : function() {
                        this.selected.clear();
                        this.lastSelected = null;
                        this.setLastFocused(null)
                    },
                    onStoreAdd : function() {
                    },
                    onStoreClear : function() {
                        var a = this.selected;
                        if (a.getCount > 0) {
                            a.clear();
                            this.lastSelected = null;
                            this.setLastFocused(null);
                            this.maybeFireSelectionChange(true)
                        }
                    },
                    onStoreRemove : function(b, a) {
                        if (this.locked) {
                            return
                        }
                        var c = this.selected;
                        if (c.remove(a)) {
                            if (this.lastSelected == a) {
                                this.lastSelected = null
                            }
                            if (this.getLastFocused() == a) {
                                this.setLastFocused(null)
                            }
                            this.maybeFireSelectionChange(true)
                        }
                    },
                    getCount : function() {
                        return this.selected.getCount()
                    },
                    destroy : function() {
                    },
                    onStoreUpdate : function() {
                    },
                    onSelectChange : function(a, c, b) {
                    },
                    onLastFocusChanged : function(b, a) {
                    },
                    onEditorKey : function(b, a) {
                    },
                    bindComponent : function(a) {
                    }
                });
Ext.DataViewSelectionModel = Ext.extend(Ext.AbstractStoreSelectionModel, {
    deselectOnContainerClick : true,
    bindComponent : function(a) {
        this.view = a;
        this.bind(a.getStore());
        var b = {
            refresh : this.refresh,
            scope : this,
            el : {
                scope : this
            }
        };
        b.el[a.triggerEvent] = this.onItemClick;
        b.el[a.triggerCtEvent] = this.onContainerClick;
        a.on(b)
    },
    onItemClick : function(c) {
        var a = this.view, b = a.findTargetByEvent(c);
        if (b) {
            this.selectWithEvent(a.getRecord(b), c)
        } else {
            return false
        }
    },
    onContainerClick : function() {
        if (this.deselectOnContainerClick) {
            this.deselectAll()
        }
    },
    onSelectChange : function(b, d, c) {
        var a = this.view;
        if (d) {
            a.onItemSelect(b);
            if (!c) {
                this.fireEvent("select", this, b)
            }
        } else {
            a.onItemDeselect(b);
            if (!c) {
                this.fireEvent("deselect", this, b)
            }
        }
    }
});
Ext.DataView = Ext
        .extend(
                Ext.Component,
                {
                    loadingText : "Loading...",
                    selectedItemCls : "x-item-selected",
                    emptyText : "",
                    deferEmptyText : true,
                    trackOver : false,
                    blockRefresh : false,
                    last : false,
                    triggerEvent : "click",
                    triggerCtEvent : "containerclick",
                    addCmpEvents : function() {
                    },
                    initComponent : function() {
                        var a = Ext.isDefined;
                        if (!a(this.tpl) || !a(this.store)
                                || !a(this.itemSelector)) {
                            throw "DataView requires tpl, store and itemSelector configurations to be defined."
                        }
                        Ext.DataView.superclass.initComponent.call(this);
                        if (Ext.isString(this.tpl) || Ext.isArray(this.tpl)) {
                            this.tpl = new Ext.XTemplate(this.tpl)
                        }
                        if (Ext.isDefined(this.overCls)
                                || Ext.isDefined(this.overClass)) {
                            this.overItemCls = this.overCls || this.overClass;
                            delete this.overCls;
                            delete this.overClass;
                            throw "Using the deprecated overCls or overClass configuration. Use overItemCls."
                        }
                        if (Ext.isDefined(this.selectedCls)
                                || Ext.isDefined(this.selectedClass)) {
                            this.selectedItemCls = this.selectedCls
                                    || this.selectedClass;
                            delete this.selectedCls;
                            delete this.selectedClass;
                            throw "Using the deprecated selectedCls or selectedClass configuration. Use selectedItemCls."
                        }
                        this.addEvents("beforerefresh", "refresh");
                        this.addCmpEvents();
                        this.store = Ext.StoreMgr.lookup(this.store);
                        this.all = new Ext.CompositeElementLite();
                        this.getSelectionModel().bindComponent(this)
                    },
                    onRender : function() {
                        Ext.DataView.superclass.onRender.apply(this, arguments);
                        if (this.loadingText) {
                            this.loadMask = new Ext.LoadMask(this.el, {
                                msg : this.loadingText
                            })
                        }
                    },
                    getSelectionModel : function() {
                        if (!this.selModel) {
                            this.selModel = {}
                        }
                        var a;
                        switch (true) {
                        case this.simpleSelect:
                            a = "SIMPLE";
                            break;
                        case this.multiSelect:
                            a = "MULTI";
                            break;
                        case this.singleSelect:
                        default:
                            a = "SINGLE";
                            break
                        }
                        Ext.applyIf(this.selModel, {
                            allowDeselect : this.allowDeselect,
                            mode : a
                        });
                        if (!this.selModel.events) {
                            this.selModel = new Ext.DataViewSelectionModel(
                                    this.selModel)
                        }
                        if (!this.selModel.hasRelaySetup) {
                            this.relayEvents(this.selModel, [
                                    "selectionchange", "select", "deselect" ]);
                            this.selModel.hasRelaySetup = true
                        }
                        if (this.disableSelection) {
                            this.selModel.locked = true
                        }
                        return this.selModel
                    },
                    refresh : function() {
                        if (!this.rendered) {
                            return
                        }
                        this.fireEvent("beforerefresh", this);
                        var b = this.getTargetEl(), a = this.store.getRange();
                        b.update("");
                        if (a.length < 1) {
                            if (!this.deferEmptyText
                                    || this.hasSkippedEmptyText) {
                                b.update(this.emptyText)
                            }
                            this.all.clear()
                        } else {
                            this.tpl.overwrite(b, this.collectData(a, 0));
                            this.all.fill(Ext.query(this.itemSelector, b.dom));
                            this.updateIndexes(0)
                        }
                        this.hasSkippedEmptyText = true;
                        this.fireEvent("refresh", this)
                    },
                    prepareData : function(c, b, a) {
                        if (a) {
                            Ext.apply(c, this.prepareAssociatedData(a))
                        }
                        return c
                    },
                    prepareAssociatedData : function(m, b) {
                        b = b || [];
                        var g = m.associations.items, k = g.length, d = {}, e, a, f, o, p, c, n, l, h;
                        for (l = 0; l < k; l++) {
                            c = g[l];
                            e = m[c.storeName];
                            d[c.name] = [];
                            if (e && e.data.length > 0) {
                                f = e.data.items;
                                p = f.length;
                                for (h = 0; h < p; h++) {
                                    o = f[h];
                                    n = o.internalId;
                                    if (b.indexOf(n) == -1) {
                                        b.push(n);
                                        d[c.name][h] = o.data;
                                        Ext.apply(d[c.name][h], this
                                                .prepareAssociatedData(o, b))
                                    }
                                }
                            }
                        }
                        return d
                    },
                    collectData : function(b, e) {
                        var d = [], c = 0, a = b.length;
                        for (; c < a; c++) {
                            d[d.length] = this.prepareData(b[c].data, e + c,
                                    b[c])
                        }
                        return d
                    },
                    bufferRender : function(a, b) {
                        var c = document.createElement("div");
                        this.tpl.overwrite(c, this.collectData(a, b));
                        return Ext.query(this.itemSelector, c)
                    },
                    onUpdate : function(e, a) {
                        var b = this.store.indexOf(a), c, d;
                        if (b > -1) {
                            c = this.all.elements[b];
                            d = this.bufferRender([ a ], b)[0];
                            this.all.replaceElement(b, d, true);
                            this.updateIndexes(b, b);
                            this.selModel.refresh()
                        }
                    },
                    onAdd : function(f, d, e) {
                        if (this.all.getCount() === 0) {
                            this.refresh();
                            return
                        }
                        var c = this.bufferRender(d, e), g, b = this.all.elements;
                        if (e < this.all.getCount()) {
                            g = this.all.item(e).insertSibling(c, "before",
                                    true);
                            b.splice.apply(b, [ e, 0 ].concat(c))
                        } else {
                            g = this.all.last().insertSibling(c, "after", true);
                            b.push.apply(b, c)
                        }
                        this.updateIndexes(e)
                    },
                    onRemove : function(c, a, b) {
                        this.all.removeElement(b, true);
                        this.updateIndexes(b);
                        if (this.store.getCount() === 0) {
                            this.refresh()
                        }
                    },
                    refreshNode : function(a) {
                        this.onUpdate(this.store, this.store.getAt(a))
                    },
                    updateIndexes : function(d, c) {
                        var b = this.all.elements;
                        d = d || 0;
                        c = c || ((c === 0) ? 0 : (b.length - 1));
                        for ( var a = d; a <= c; a++) {
                            b[a].viewIndex = a
                        }
                    },
                    getStore : function() {
                        return this.store
                    },
                    bindStore : function(a, b) {
                        if (!b && this.store) {
                            if (a !== this.store && this.store.autoDestroy) {
                                this.store.destroy()
                            } else {
                                this.mun(this.store, {
                                    scope : this,
                                    beforeload : this.onBeforeLoad,
                                    datachanged : this.onDataChanged,
                                    add : this.onAdd,
                                    remove : this.onRemove,
                                    update : this.onUpdate,
                                    clear : this.refresh
                                })
                            }
                            if (!a) {
                                if (this.loadMask) {
                                    this.loadMask.bindStore(null)
                                }
                                this.store = null
                            }
                        }
                        if (a) {
                            a = Ext.StoreMgr.lookup(a);
                            this.mon(a, {
                                scope : this,
                                beforeload : this.onBeforeLoad,
                                datachanged : this.onDataChanged,
                                add : this.onAdd,
                                remove : this.onRemove,
                                update : this.onUpdate,
                                clear : this.refresh
                            });
                            if (this.loadMask) {
                                this.loadMask.bindStore(a)
                            }
                        }
                        this.store = a;
                        this.getSelectionModel().bind(a);
                        if (a) {
                            this.refresh()
                        }
                    },
                    onDataChanged : function() {
                        if (this.blockRefresh !== true) {
                            this.refresh.apply(this, arguments)
                        }
                    },
                    findItemByChild : function(a) {
                        return Ext.fly(a).findParent(this.itemSelector,
                                this.getTargetEl())
                    },
                    findTargetByEvent : function(a) {
                        return a.getTarget(this.itemSelector, this
                                .getTargetEl())
                    },
                    getSelectedNodes : function() {
                        var b = [], a = this.selModel.getSelection(), d = a.length, c = 0;
                        for (; c < d; c++) {
                            b.push(this.getNode(a[c]))
                        }
                        return b
                    },
                    getRecords : function(c) {
                        var b = [], d = 0, a = c.length;
                        for (; d < a; d++) {
                            b[b.length] = this.store.getAt(c[d].viewIndex)
                        }
                        return r
                    },
                    getRecord : function(a) {
                        return this.store.getAt(a.viewIndex)
                    },
                    isSelected : function(b) {
                        var a = this.getRecord(b);
                        return this.selModel.isSelected(a)
                    },
                    select : function(b, c, a) {
                        this.selModel.select(b, c, a)
                    },
                    deselect : function(b, a) {
                        this.selModel.deselect(b, a)
                    },
                    getNode : function(b) {
                        if (Ext.isString(b)) {
                            return document.getElementById(b)
                        } else {
                            if (Ext.isNumber(b)) {
                                return this.all.elements[b]
                            } else {
                                if (b instanceof Ext.data.Model) {
                                    var a = this.store.indexOf(b);
                                    return this.all.elements[a]
                                }
                            }
                        }
                        return b
                    },
                    getNodes : function(e, a) {
                        var d = this.all.elements, b = [], c;
                        e = e || 0;
                        a = !Ext.isDefined(a) ? Math.max(d.length - 1, 0) : a;
                        if (e <= a) {
                            for (c = e; c <= a && d[c]; c++) {
                                b.push(d[c])
                            }
                        } else {
                            for (c = e; c >= a && d[c]; c--) {
                                b.push(d[c])
                            }
                        }
                        return b
                    },
                    indexOf : function(a) {
                        a = this.getNode(a);
                        if (Ext.isNumber(a.viewIndex)) {
                            return a.viewIndex
                        }
                        return this.all.indexOf(a)
                    },
                    onBeforeLoad : function() {
                        if (this.loadingText) {
                            this.getTargetEl().update("");
                            this.all.clear()
                        }
                    },
                    onDestroy : function() {
                        this.all.clear();
                        Ext.DataView.superclass.onDestroy.call(this);
                        this.bindStore(null);
                        this.selModel.destroy()
                    },
                    onItemSelect : function(a) {
                        var b = this.getNode(a);
                        Ext.fly(b).addCls(this.selectedItemCls)
                    },
                    onItemDeselect : function(a) {
                        var b = this.getNode(a);
                        Ext.fly(b).removeCls(this.selectedItemCls)
                    },
                    select : function(a, b, d) {
                        console
                                .warn("DataView: select will be removed, please access select through a DataView's SelectionModel, ie: view.getSelectionModel().select()");
                        var c = this.getSelectionModel();
                        return c.select.apply(c, arguments)
                    },
                    clearSelections : function() {
                        console
                                .warn("DataView: clearSelections will be removed, please access deselectAll through DataView's SelectionModel, ie: view.getSelectionModel().deselectAll()");
                        var a = this.getSelectionModel();
                        return a.deselectAll()
                    }
                });
Ext.reg("dataview", Ext.DataView);
Ext.DataView.override({
    getSelectionCount : function() {
        return this.selModel.getSelection().length
    },
    getSelectedRecords : function() {
        return this.selModel.getSelection()
    }
});
Ext.DataView.override({
    scroll : "vertical",
    pressedCls : "x-item-pressed",
    pressedDelay : 100,
    allowDeselect : true,
    triggerEvent : "singletap",
    triggerCtEvent : "containertap",
    addCmpEvents : function() {
        this.addEvents("itemtap", "itemdoubletap", "itemswipe", "containertap",
                "selectionchange", "beforeselect")
    },
    afterRender : function() {
        var a = this;
        Ext.DataView.superclass.afterRender.call(a);
        var b = {
            tapstart : a.onTapStart,
            tapcancel : a.onTapCancel,
            touchend : a.onTapCancel,
            doubletap : a.onDoubleTap,
            swipe : a.onSwipe,
            scope : a
        };
        b[this.triggerEvent] = a.onTap;
        a.mon(a.getTargetEl(), b);
        if (this.store) {
            this.bindStore(this.store, true)
        }
    },
    onTap : function(c) {
        var b = this.findTargetByEvent(c);
        if (b) {
            Ext.fly(b).removeCls(this.pressedCls);
            var a = this.indexOf(b);
            if (this.onItemTap(b, a, c) !== false) {
                this.fireEvent("itemtap", this, a, b, c)
            }
        } else {
            if (this.fireEvent("containertap", this, c) !== false) {
                this.onContainerTap(c)
            }
        }
    },
    onTapStart : function(d, a) {
        var c = this, b = this.findTargetByEvent(d);
        if (b) {
            if (c.pressedDelay) {
                if (c.pressedTimeout) {
                    clearTimeout(c.pressedTimeout)
                }
                c.pressedTimeout = setTimeout(function() {
                    Ext.fly(b).addCls(c.pressedCls)
                }, Ext.isNumber(c.pressedDelay) ? c.pressedDelay : 100)
            } else {
                Ext.fly(b).addCls(c.pressedCls)
            }
        }
    },
    onTapCancel : function(d, a) {
        var c = this, b = this.findTargetByEvent(d);
        if (c.pressedTimeout) {
            clearTimeout(c.pressedTimeout);
            delete c.pressedTimeout
        }
        if (b) {
            Ext.fly(b).removeCls(c.pressedCls)
        }
    },
    onContainerTap : function(a) {
    },
    onDoubleTap : function(b) {
        var a = this.findTargetByEvent(b);
        if (a) {
            this.fireEvent("itemdoubletap", this, this.indexOf(a), a, b)
        }
    },
    onSwipe : function(b) {
        var a = this.findTargetByEvent(b);
        if (a) {
            this.fireEvent("itemswipe", this, this.indexOf(a), a, b)
        }
    },
    onItemTap : function(b, a, c) {
        if (this.pressedTimeout) {
            clearTimeout(this.pressedTimeout);
            delete this.pressedTimeout
        }
        return true
    }
});
Ext.List = Ext
        .extend(
                Ext.DataView,
                {
                    componentCls : "x-list",
                    pinHeaders : Ext.is.iOS || Ext.is.Desktop,
                    indexBar : false,
                    grouped : false,
                    clearSelectionOnDeactivate : true,
                    renderTpl : [ '<tpl if="grouped"><h3 class="x-list-header x-list-header-swap x-hidden-display"></h3></tpl>' ],
                    groupTpl : [ '<tpl for=".">',
                            '<div class="x-list-group x-group-{id}">',
                            '<h3 class="x-list-header">{group}</h3>',
                            '<div class="x-list-group-items">', "{items}",
                            "</div>", "</div>", "</tpl>" ],
                    itemSelector : ".x-list-item",
                    itemCls : "",
                    onItemDisclosure : false,
                    preventSelectionOnDisclose : true,
                    initComponent : function() {
                        var a = {};
                        if (Ext.isArray(this.itemTpl)) {
                            this.itemTpl = this.itemTpl.join("")
                        } else {
                            if (this.itemTpl && this.itemTpl.html) {
                                Ext.apply(a, this.itemTpl.initialConfig);
                                this.itemTpl = this.itemTpl.html
                            }
                        }
                        if (!Ext.isDefined(this.itemTpl)) {
                            throw new Error(
                                    "Ext.List: itemTpl is a required configuration.")
                        }
                        if (this.itemTpl
                                && this.itemTpl.indexOf('"x-list-item"') !== -1) {
                            throw new Error(
                                    "Ext.List: Using a CSS class of x-list-item within your own tpl will break Ext.Lists. Remove the x-list-item from the tpl/itemTpl")
                        }
                        this.tpl = '<tpl for="."><div class="x-list-item '
                                + this.itemCls
                                + '"><div class="x-list-item-body">'
                                + this.itemTpl + "</div>";
                        if (this.onItemDisclosure) {
                            this.tpl += '<div class="x-list-disclosure"></div>'
                        }
                        this.tpl += "</div></tpl>";
                        this.tpl = new Ext.XTemplate(this.tpl, a);
                        if (this.grouped) {
                            this.listItemTpl = this.tpl;
                            if (Ext.isString(this.listItemTpl)
                                    || Ext.isArray(this.listItemTpl)) {
                                this.listItemTpl = new Ext.XTemplate(
                                        this.listItemTpl, a)
                            }
                            if (Ext.isString(this.groupTpl)
                                    || Ext.isArray(this.groupTpl)) {
                                this.tpl = new Ext.XTemplate(this.groupTpl)
                            }
                        } else {
                            this.indexBar = false
                        }
                        if (this.scroll !== false) {
                            this.scroll = {
                                direction : "vertical",
                                useIndicators : !this.indexBar
                            }
                        }
                        Ext.List.superclass.initComponent.call(this);
                        if (this.onItemDisclosure) {
                            if (Ext.isFunction(this.onItemDisclosure)) {
                                this.onItemDisclosure = {
                                    scope : this,
                                    handler : this.onItemDisclosure
                                }
                            }
                        }
                        this.on("deactivate", this.onDeactivate, this);
                        this.addEvents("disclose", "update")
                    },
                    onRender : function() {
                        if (this.grouped) {
                            Ext.applyIf(this.renderData, {
                                grouped : true
                            });
                            if (this.scroll) {
                                Ext.applyIf(this.renderSelectors, {
                                    header : ".x-list-header-swap"
                                })
                            }
                        }
                        Ext.List.superclass.onRender.apply(this, arguments)
                    },
                    onDeactivate : function() {
                        if (this.clearSelectionOnDeactivate) {
                            this.getSelectionModel().deselectAll()
                        }
                    },
                    afterRender : function() {
                        if (!this.grouped) {
                            this.el.addCls("x-list-flat")
                        }
                        this.getTargetEl().addCls("x-list-parent");
                        if (this.indexBar) {
                            this.indexBar = new Ext.IndexBar(Ext.apply({}, Ext
                                    .isObject(this.indexBar) ? this.indexBar
                                    : {}, {
                                xtype : "indexbar",
                                alphabet : true,
                                renderTo : this.el
                            }));
                            this.addCls("x-list-indexed")
                        }
                        Ext.List.superclass.afterRender.call(this);
                        if (this.onItemDisclosure) {
                            this.mon(this.getTargetEl(), "singletap",
                                    this.handleItemDisclosure, this, {
                                        delegate : ".x-list-disclosure"
                                    })
                        }
                    },
                    initEvents : function() {
                        Ext.List.superclass.initEvents.call(this);
                        if (this.grouped) {
                            if (this.pinHeaders && this.scroll) {
                                this.mon(this.scroller, {
                                    scrollstart : this.onScrollStart,
                                    scroll : this.onScroll,
                                    scope : this
                                })
                            }
                            if (this.indexBar) {
                                this.mon(this.indexBar, {
                                    index : this.onIndex,
                                    scope : this
                                })
                            }
                        }
                    },
                    handleItemDisclosure : function(f, c) {
                        var d = this.findItemByChild(c), a, b;
                        if (d) {
                            a = this.getRecord(d);
                            b = this.indexOf(d);
                            if (this.preventSelectionOnDisclose) {
                                f.stopEvent()
                            }
                            this.fireEvent("disclose", a, d, b, f);
                            if (Ext.isObject(this.onItemDisclosure)
                                    && this.onItemDisclosure.handler) {
                                this.onItemDisclosure.handler.call(this, a, d,
                                        b)
                            }
                        }
                    },
                    setActiveGroup : function(b) {
                        var a = this;
                        if (b) {
                            if (!a.activeGroup
                                    || a.activeGroup.header != b.header) {
                                a.header.setHTML(b.header.getHTML());
                                a.header.show()
                            }
                        } else {
                            a.header.hide()
                        }
                        this.activeGroup = b
                    },
                    getClosestGroups : function(g) {
                        if (!this.groupOffsets) {
                            this.updateOffsets()
                        }
                        var a = this.groupOffsets, d = a.length, f, b, e, c;
                        for (b = 0; b < d; b++) {
                            f = a[b];
                            if (f.offset > g.y) {
                                c = f;
                                break
                            }
                            e = f
                        }
                        return {
                            current : e,
                            next : c
                        }
                    },
                    updateIndexes : function() {
                        Ext.List.superclass.updateIndexes
                                .apply(this, arguments);
                        this.updateList()
                    },
                    afterComponentLayout : function() {
                        Ext.List.superclass.afterComponentLayout.apply(this,
                                arguments);
                        this.updateList()
                    },
                    updateList : function() {
                        this.fireEvent("update", this);
                        this.updateOffsets()
                    },
                    updateOffsets : function() {
                        if (this.grouped) {
                            this.groupOffsets = [];
                            var c = this.getTargetEl()
                                    .query("h3.x-list-header"), b = c.length, d, a;
                            for (a = 0; a < b; a++) {
                                d = Ext.get(c[a]);
                                d.setVisibilityMode(Ext.Element.VISIBILITY);
                                this.groupOffsets.push({
                                    header : d,
                                    offset : d.dom.offsetTop
                                })
                            }
                        }
                    },
                    onScrollStart : function() {
                        var a = this.scroller.getOffset();
                        this.closest = this.getClosestGroups(a);
                        this.setActiveGroup(this.closest.current)
                    },
                    onScroll : function(a, d, c) {
                        if (!this.closest) {
                            this.closest = this.getClosestGroups(d)
                        }
                        if (!this.headerHeight) {
                            this.headerHeight = this.header.getHeight()
                        }
                        if (d.y <= 0) {
                            if (this.activeGroup) {
                                this.setActiveGroup(false);
                                this.closest.next = this.closest.current
                            }
                            return
                        } else {
                            if ((this.closest.next && d.y > this.closest.next.offset)
                                    || (d.y < this.closest.current.offset)) {
                                this.closest = this.getClosestGroups(d);
                                this.setActiveGroup(this.closest.current)
                            }
                        }
                        if (this.closest.next
                                && d.y > 0
                                && this.closest.next.offset - d.y <= this.headerHeight) {
                            var b = this.headerHeight
                                    - (this.closest.next.offset - d.y);
                            Ext.Element.cssTranslate(this.header, {
                                x : 0,
                                y : -b
                            });
                            this.transformed = true
                        } else {
                            if (this.transformed) {
                                this.header.setStyle("-webkit-transform", null);
                                this.transformed = false
                            }
                        }
                    },
                    onIndex : function(e, g, f) {
                        var k = e.get("key").toLowerCase(), c = this.store
                                .getGroups(), h = c.length, j, d, b, a;
                        for (d = 0; d < h; d++) {
                            j = c[d];
                            a = this.getGroupId(j);
                            if (a == k || a > k) {
                                b = a;
                                break
                            } else {
                                b = a
                            }
                        }
                        b = this.getTargetEl().down(".x-group-" + a);
                        if (b) {
                            this.scroller.scrollTo({
                                x : 0,
                                y : b.getOffsetsTo(this.scrollEl)[1]
                            }, false, null, true)
                        }
                    },
                    getGroupId : function(a) {
                        return a.name.toLowerCase()
                    },
                    collectData : function(e, l) {
                        if (!this.grouped) {
                            return Ext.List.superclass.collectData.call(this,
                                    e, l)
                        }
                        var g = [], d = this.store.getGroups(), h = d.length, b, a, j, k, f;
                        for (f = 0, h = d.length; f < h; f++) {
                            k = d[f];
                            b = k.children;
                            for (j = 0, a = b.length; j < a; j++) {
                                b[j] = b[j].data
                            }
                            g.push({
                                group : k.name,
                                id : this.getGroupId(k),
                                items : this.listItemTpl.apply(b)
                            })
                        }
                        return g
                    },
                    onUpdate : function(b, a) {
                        if (this.grouped) {
                            this.refresh()
                        } else {
                            Ext.List.superclass.onUpdate.apply(this, arguments)
                        }
                    },
                    onAdd : function(c, a, b) {
                        if (this.grouped) {
                            this.refresh()
                        } else {
                            Ext.List.superclass.onAdd.apply(this, arguments)
                        }
                    },
                    onRemove : function(c, a, b) {
                        if (this.grouped) {
                            this.refresh()
                        } else {
                            Ext.List.superclass.onRemove.apply(this, arguments)
                        }
                    }
                });
Ext.reg("list", Ext.List);
Ext.IndexBar = Ext.extend(Ext.DataView, {
    componentCls : "x-indexbar",
    direction : "vertical",
    tpl : '<tpl for="."><div class="x-indexbar-item">{value}</div></tpl>',
    itemSelector : "div.x-indexbar-item",
    letters : [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
            "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y",
            "Z" ],
    listPrefix : "",
    componentLayout : "autocomponent",
    scroll : false,
    initComponent : function() {
        this.componentLayout = this.getComponentLayout();
        if (!this.store) {
            this.store = new Ext.data.Store({
                model : "IndexBarModel"
            })
        }
        if (this.alphabet == true) {
            this.ui = this.ui || "alphabet"
        }
        if (this.direction == "horizontal") {
            this.horizontal = true
        } else {
            this.vertical = true
        }
        this.addEvents("index");
        Ext.apply(this.renderData, {
            componentCls : this.componentCls
        });
        Ext.apply(this.renderSelectors, {
            body : "." + this.componentCls + "-body"
        });
        Ext.IndexBar.superclass.initComponent.call(this)
    },
    renderTpl : [ '<div class="{componentCls}-body"></div>' ],
    getTargetEl : function() {
        return this.body
    },
    afterRender : function() {
        Ext.IndexBar.superclass.afterRender.call(this);
        if (this.alphabet === true) {
            this.loadAlphabet()
        }
        if (this.vertical) {
            this.el.addCls(this.componentCls + "-vertical")
        } else {
            if (this.horizontal) {
                this.el.addCls(this.componentCls + "-horizontal")
            }
        }
    },
    loadAlphabet : function() {
        var e = this.letters, a = e.length, d = [], b, c;
        for (b = 0; b < a; b++) {
            c = e[b];
            d.push({
                key : c.toLowerCase(),
                value : c
            })
        }
        this.store.loadData(d)
    },
    refresh : function() {
        var b = this.getTargetEl(), a = this.store.getRange();
        b.update("");
        if (a.length < 1) {
            if (!this.deferEmptyText || this.hasSkippedEmptyText) {
                b.update(this.emptyText)
            }
            this.all.clear()
        } else {
            this.tpl.overwrite(b, this.collectData(a, 0));
            this.all.fill(Ext.query(this.itemSelector, b.dom));
            this.updateIndexes(0)
        }
        this.hasSkippedEmptyText = true;
        this.fireEvent("refresh")
    },
    collectData : function() {
        var a = Ext.IndexBar.superclass.collectData.apply(this, arguments);
        if (this.listPrefix.length > 0) {
            a.unshift({
                key : "",
                value : this.listPrefix
            })
        }
        return a
    },
    initEvents : function() {
        Ext.IndexBar.superclass.initEvents.call(this);
        this.mon(this.el, {
            touchstart : this.onTouchStart,
            touchend : this.onTouchEnd,
            touchmove : this.onTouchMove,
            scope : this
        })
    },
    onTouchStart : function(b, a) {
        b.stopEvent();
        this.el.addCls(this.componentCls + "-pressed");
        this.pageBox = this.el.getPageBox();
        this.onTouchMove(b)
    },
    onTouchEnd : function(b, a) {
        b.stopEvent();
        this.el.removeCls(this.componentCls + "-pressed")
    },
    onTouchMove : function(d) {
        d.stopPropagation();
        var a = Ext.util.Point.fromEvent(d), c, b, f = this.pageBox;
        if (!f) {
            f = this.pageBox = this.el.getPageBox()
        }
        if (this.vertical) {
            if (a.y > f.bottom || a.y < f.top) {
                return
            }
            c = Ext.Element.fromPoint(f.left + (f.width / 2), a.y)
        } else {
            if (this.horizontal) {
                if (a.x > f.right || a.x < f.left) {
                    return
                }
                c = Ext.Element.fromPoint(a.x, f.top + (f.height / 2))
            }
        }
        if (c) {
            b = this.getRecord(c.dom);
            if (b) {
                this.fireEvent("index", b, c, this.indexOf(c))
            }
        }
    },
    isVertical : function() {
        return this.vertical
    },
    isHorizontal : function() {
        return this.horizontal
    }
});
Ext.reg("indexbar", Ext.IndexBar);
Ext.regModel("IndexBarModel", {
    fields : [ "key", "value" ]
});
Ext.Toolbar = Ext.extend(Ext.Container, {
    isToolbar : true,
    defaultType : "button",
    baseCls : "x-toolbar",
    titleCls : "x-toolbar-title",
    ui : "dark",
    layout : null,
    titleEl : null,
    initComponent : function() {
        this.layout = Ext.apply({}, this.layout || {}, {
            type : "hbox",
            align : "center"
        });
        Ext.Toolbar.superclass.initComponent.call(this)
    },
    afterRender : function() {
        Ext.Toolbar.superclass.afterRender.call(this);
        if (this.title) {
            this.titleEl = this.el.createChild({
                cls : this.titleCls,
                html : this.title
            })
        }
    },
    setTitle : function(a) {
        this.title = a;
        if (this.rendered) {
            if (!this.titleEl) {
                this.titleEl = this.el.createChild({
                    cls : this.titleCls,
                    html : this.title
                })
            }
            this.titleEl.setHTML(a)
        }
    },
    showTitle : function() {
        if (this.titleEl) {
            this.titleEl.show()
        }
    },
    hideTitle : function() {
        if (this.titleEl) {
            this.titleEl.hide()
        }
    }
});
Ext.reg("toolbar", Ext.Toolbar);
Ext.Spacer = Ext.extend(Ext.Component, {
    initComponent : function() {
        if (!this.width) {
            this.flex = 1
        }
        Ext.Spacer.superclass.initComponent.call(this)
    },
    onRender : function() {
        Ext.Spacer.superclass.onRender.apply(this, arguments);
        if (this.flex) {
            this.el.setStyle("-webkit-box-flex", this.flex)
        }
    }
});
Ext.reg("spacer", Ext.Spacer);
Ext.Sheet = Ext
        .extend(
                Ext.Panel,
                {
                    baseCls : "x-sheet",
                    centered : false,
                    floating : true,
                    modal : true,
                    draggable : false,
                    monitorOrientation : true,
                    hidden : true,
                    hideOnMaskTap : false,
                    enter : "bottom",
                    exit : "bottom",
                    enterAnimation : "slide",
                    exitAnimation : "slide",
                    transitions : {
                        bottom : "up",
                        top : "down",
                        right : "left",
                        left : "right"
                    },
                    animSheet : function(a) {
                        var d = null, b = this, c = b.transitions, e = Ext.Anim.prototype.opposites
                                || {};
                        if (a && this[a]) {
                            if (a == "enter") {
                                d = (typeof b.enterAnimation == "string") ? {
                                    type : b.enterAnimation || "slide",
                                    direction : c[b.enter] || "up"
                                } : b.enterAnimation
                            } else {
                                if (a == "exit") {
                                    d = (typeof b.exitAnimation == "string") ? {
                                        type : b.exitAnimation || "slide",
                                        direction : c[b.exit] || "down"
                                    }
                                            : b.exitAnimation
                                }
                            }
                        }
                        return d
                    },
                    orient : function(a, j, d) {
                        if (!this.container || this.centered || !this.floating) {
                            return this
                        }
                        var g = this, e = g.initialConfig || {}, k = {
                            width : e.width,
                            height : e.height
                        }, i = {
                            x : e.x,
                            y : e.y
                        }, c = g.el.getPageBox(), f, b = 0;
                        if (g.container.dom == document.body) {
                            f = {
                                width : window.innerWidth,
                                height : window.innerHeight
                            };
                            b = document.body.scrollTop
                        } else {
                            f = g.container.getPageBox()
                        }
                        f.centerY = f.height / 2;
                        f.centerX = f.width / 2;
                        if (i.x != undefined || i.y != undefined) {
                            i.x = i.x || 0;
                            i.y = i.y || 0
                        } else {
                            if (/^(bottom|top)/i.test(g.enter)) {
                                k.width = g.stretchX ? f.width : Math.min(200,
                                        Math.max(k.width || c.width || f.width,
                                                f.width));
                                k.height = Math.min(k.height || 0, f.height)
                                        || undefined;
                                k = g.setSize(k).getSize();
                                i.x = f.centerX - k.width / 2;
                                i.y = g.enter == "top" ? 0 : f.height
                                        - k.height + b
                            } else {
                                if (/^(left|right)/i.test(g.enter)) {
                                    k.height = g.stretchY ? f.height : Math
                                            .min(200, Math.max(k.height
                                                    || c.height || f.height,
                                                    f.height));
                                    k.width = Math.min(k.width || 0, f.width)
                                            || undefined;
                                    k = g.setSize(k).getSize();
                                    i.y = 0;
                                    i.x = g.enter == "left" ? 0 : f.width
                                            - k.width
                                }
                            }
                        }
                        g.setPosition(i);
                        return this
                    },
                    afterRender : function() {
                        Ext.Sheet.superclass.afterRender.apply(this, arguments);
                        this.el.setVisibilityMode(Ext.Element.OFFSETS)
                    },
                    onShow : function(a) {
                        this.orient();
                        return Ext.Sheet.superclass.onShow.call(this, a
                                || this.animSheet("enter"))
                    },
                    onOrientationChange : function(b, a, c) {
                        this.orient();
                        Ext.Sheet.superclass.onOrientationChange.apply(this,
                                arguments)
                    },
                    beforeDestroy : function() {
                        delete this.showAnimation;
                        this.hide(false);
                        Ext.Sheet.superclass.beforeDestroy.call(this)
                    }
                });
Ext.reg("sheet", Ext.Sheet);
Ext.ActionSheet = Ext.extend(Ext.Sheet, {
    componentCls : "x-sheet-action",
    stretchY : true,
    stretchX : true,
    defaultType : "button",
    constructor : function(a) {
        a = a || {};
        Ext.ActionSheet.superclass.constructor.call(this, Ext.applyIf({
            floating : true
        }, a))
    }
});
Ext.reg("actionsheet", Ext.ActionSheet);
Ext.TabBar = Ext.extend(Ext.Panel, {
    componentCls : "x-tabbar",
    activeTab : null,
    defaultType : "tab",
    sortable : false,
    sortHoldThreshold : 350,
    initComponent : function() {
        this.addEvents("change");
        this.layout = Ext.apply({}, this.layout || {}, {
            type : "hbox",
            align : "middle"
        });
        Ext.TabBar.superclass.initComponent.call(this)
    },
    initEvents : function() {
        if (this.sortable) {
            this.sortable = new Ext.util.Sortable(this.el, {
                itemSelector : ".x-tab",
                direction : "horizontal",
                delay : this.sortHoldThreshold,
                constrain : true
            });
            this.mon(this.sortable, "sortchange", this.onSortChange, this)
        }
        this.mon(this.el, {
            touchstart : this.onTouchStart,
            scope : this
        });
        Ext.TabBar.superclass.initEvents.call(this)
    },
    onTouchStart : function(b, a) {
        a = b.getTarget(".x-tab");
        if (a) {
            this.onTabTap(Ext.getCmp(a.id))
        }
    },
    onSortChange : function(c, b, a) {
    },
    onTabTap : function(a) {
        if (!a.disabled) {
            if (this.cardLayout) {
                if (this.cardSwitchAnimation) {
                    var b = {
                        reverse : (this.items.indexOf(a) < this.items
                                .indexOf(this.activeTab)) ? true : false
                    };
                    if (Ext.isObject(this.cardSwitchAnimation)) {
                        Ext.apply(b, this.cardSwitchAnimation)
                    } else {
                        Ext.apply(b, {
                            type : this.cardSwitchAnimation
                        })
                    }
                }
                this.cardLayout.setActiveItem(a.card, b
                        || this.cardSwitchAnimation)
            }
            this.activeTab = a;
            this.fireEvent("change", this, a, a.card)
        }
    },
    getCardLayout : function() {
        return this.cardLayout
    }
});
Ext.reg("tabbar", Ext.TabBar);
Ext.Tab = Ext.extend(Ext.Button, {
    isTab : true,
    baseCls : "x-tab",
    pressedCls : "x-tab-pressed",
    activeCls : "x-tab-active",
    active : false,
    initComponent : function() {
        this.addEvents("activate", "deactivate");
        Ext.Tab.superclass.initComponent.call(this);
        var a = this.card;
        if (a) {
            this.card = null;
            this.setCard(a)
        }
    },
    setCard : function(a) {
        if (this.card) {
            this.mun(this.card, {
                activate : this.activate,
                deactivate : this.deactivate,
                scope : this
            })
        }
        this.card = a;
        if (a) {
            Ext.apply(this, a.tab || {});
            this.setText(this.title || a.title || this.text);
            this.setIconClass(this.iconCls || a.iconCls);
            this.setBadge(this.badgeText || a.badgeText);
            this.mon(a, {
                beforeactivate : this.activate,
                beforedeactivate : this.deactivate,
                scope : this
            })
        }
    },
    onRender : function() {
        Ext.Tab.superclass.onRender.apply(this, arguments);
        if (this.active) {
            this.el.addCls(this.activeCls)
        }
    },
    getCard : function() {
        return this.card
    },
    activate : function() {
        this.active = true;
        if (this.el) {
            this.el.addCls(this.activeCls)
        }
        this.fireEvent("activate", this)
    },
    deactivate : function() {
        this.active = false;
        if (this.el) {
            this.el.removeCls(this.activeCls)
        }
        this.fireEvent("deactivate", this)
    }
});
Ext.reg("tab", Ext.Tab);
Ext.TabPanel = Ext.extend(Ext.Panel, {
    cardSwitchAnimation : "slide",
    tabBarDock : "top",
    componentCls : "x-tabpanel",
    ui : "dark",
    initComponent : function() {
        var a = new Ext.layout.CardLayout(this.layout || {});
        this.layout = null;
        this.setLayout(a);
        this.tabBar = new Ext.TabBar(Ext.apply({}, this.tabBar || {}, {
            cardLayout : a,
            cardSwitchAnimation : this.cardSwitchAnimation,
            dock : this.tabBarDock,
            ui : this.ui,
            sortable : this.sortable
        }));
        if (this.dockedItems && !Ext.isArray(this.dockedItems)) {
            this.dockedItems = [ this.dockedItems ]
        } else {
            if (!this.dockedItems) {
                this.dockedItems = []
            }
        }
        this.dockedItems.push(this.tabBar);
        Ext.TabPanel.superclass.initComponent.call(this)
    },
    getTabBar : function() {
        return this.tabBar
    },
    onAdd : function(c, b) {
        var a = this.tabBar;
        c.tab = a.insert(b, {
            xtype : "tab",
            card : c
        });
        a.doLayout()
    },
    onRemove : function(b, a) {
        if (!this.destroying) {
            this.tabBar.remove(b.tab, a);
            this.tabBar.doLayout()
        }
    }
});
Ext.reg("tabpanel", Ext.TabPanel);
Ext.Carousel = Ext
        .extend(
                Ext.Panel,
                {
                    baseCls : "x-carousel",
                    indicator : true,
                    ui : "dark",
                    direction : "horizontal",
                    horizontal : false,
                    vertical : false,
                    initComponent : function() {
                        this.layout = {
                            type : "card",
                            sizeAllCards : true,
                            hideInactive : false,
                            itemCls : "x-carousel-item",
                            targetCls : "x-carousel-body",
                            setOwner : function(b) {
                                Ext.layout.CardLayout.superclass.setOwner.call(
                                        this, b)
                            }
                        };
                        if (this.indicator) {
                            var a = Ext.isObject(this.indicator) ? this.indicator
                                    : {};
                            this.indicator = new Ext.Carousel.Indicator(Ext
                                    .apply({}, a, {
                                        direction : this.direction,
                                        carousel : this,
                                        ui : this.ui
                                    }))
                        }
                        if (this.direction == "horizontal") {
                            this.horizontal = true
                        } else {
                            this.vertical = true
                        }
                        Ext.Carousel.superclass.initComponent.call(this)
                    },
                    afterRender : function() {
                        Ext.Carousel.superclass.afterRender.call(this);
                        this.mon(this.body, {
                            drag : this.onDrag,
                            dragThreshold : 5,
                            dragend : this.onDragEnd,
                            direction : this.direction,
                            scope : this
                        });
                        this.el.addCls(this.baseCls + "-" + this.direction)
                    },
                    onAdd : function() {
                        Ext.Carousel.superclass.onAdd.apply(this, arguments);
                        var a = this.indicator;
                        if (a) {
                            a.onCardAdd()
                        }
                    },
                    onRemove : function() {
                        Ext.Carousel.superclass.onRemove.apply(this, arguments);
                        var a = this.indicator;
                        if (a) {
                            a.onCardRemove()
                        }
                    },
                    afterLayout : function() {
                        Ext.Carousel.superclass.afterLayout.apply(this,
                                arguments);
                        this.currentSize = this.body.getSize();
                        this.currentScroll = {
                            x : 0,
                            y : 0
                        };
                        this.updateCardPositions();
                        var a = this.layout.getActiveItem();
                        if (a && this.indicator) {
                            this.indicator.onBeforeCardSwitch(this, a, null,
                                    this.items.indexOf(a))
                        }
                    },
                    onDrag : function(b) {
                        this.currentScroll = {
                            x : b.deltaX,
                            y : b.deltaY
                        };
                        var a = this.items.items
                                .indexOf(this.layout.activeItem);
                        if (this.horizontal) {
                            if ((a == 0 && b.deltaX > 0)
                                    || (a == this.items.length - 1 && b.deltaX < 0)) {
                                this.currentScroll.x = b.deltaX / 2
                            }
                        } else {
                            if (this.vertical) {
                                if ((a == 0 && b.deltaY > 0)
                                        || (a == this.items.length - 1 && b.deltaY < 0)) {
                                    this.currentScroll.y = b.deltaY / 2
                                }
                            }
                        }
                        this.updateCardPositions()
                    },
                    updateCardPositions : function(a) {
                        var g = this.items.items, f = g.length, h, c, b, e, d;
                        for (c = 0; c < f; c++) {
                            b = g[c];
                            if (this.isCardInRange(b)) {
                                if (b.hidden) {
                                    b.show()
                                }
                                e = b.el;
                                d = e.dom.style;
                                if (a) {
                                    if (b === this.layout.activeItem) {
                                        e.on("webkitTransitionEnd",
                                                this.onTransitionEnd, this, {
                                                    single : true
                                                })
                                    }
                                    d.webkitTransitionDuration = "300ms"
                                } else {
                                    d.webkitTransitionDuration = "0ms"
                                }
                                h = this.getCardOffset(b);
                                if (this.horizontal) {
                                    Ext.Element.cssTransform(e, {
                                        translate : [ h, 0 ]
                                    })
                                } else {
                                    Ext.Element.cssTransform(e, {
                                        translate : [ 0, h ]
                                    })
                                }
                            } else {
                                if (!b.hidden) {
                                    b.hide()
                                }
                            }
                        }
                    },
                    getCardOffset : function(c) {
                        var d = this.getCardIndexOffset(c), b = this.currentSize, a = this.currentScroll;
                        return this.horizontal ? (d * b.width) + a.x
                                : (d * b.height) + a.y
                    },
                    getCardIndexOffset : function(a) {
                        return this.items.items.indexOf(a)
                                - this.getActiveIndex()
                    },
                    isCardInRange : function(a) {
                        return Math.abs(this.getCardIndexOffset(a)) <= 2
                    },
                    getActiveIndex : function() {
                        return this.items.indexOf(this.layout.activeItem)
                    },
                    onDragEnd : function(d, b) {
                        var a, c;
                        if (this.horizontal) {
                            c = d.deltaX;
                            a = d.previousDeltaX
                        } else {
                            c = d.deltaY;
                            a = d.previousDeltaY
                        }
                        if (c < 0 && Math.abs(c) > 3 && a <= 0
                                && this.layout.getNext()) {
                            this.next()
                        } else {
                            if (c > 0 && Math.abs(c) > 3 && a >= 0
                                    && this.layout.getPrev()) {
                                this.prev()
                            } else {
                                this.scrollToCard(this.layout.activeItem)
                            }
                        }
                    },
                    onBeforeCardSwitch : function(a) {
                        if (!this.customDrag && this.items.indexOf(a) != -1) {
                            var b = a.el.dom.style;
                            b.webkitTransitionDuration = null;
                            b.webkitTransform = null
                        }
                        return Ext.Carousel.superclass.onBeforeCardSwitch
                                .apply(this, arguments)
                    },
                    scrollToCard : function(a) {
                        this.currentScroll = {
                            x : 0,
                            y : 0
                        };
                        this.oldCard = this.layout.activeItem;
                        if (a != this.oldCard
                                && this.isCardInRange(a)
                                && this.onBeforeCardSwitch(a, this.oldCard,
                                        this.items.indexOf(a), true) !== false) {
                            this.layout.activeItem = a;
                            if (this.horizontal) {
                                this.currentScroll.x = -this.getCardOffset(a)
                            } else {
                                this.currentScroll.y = -this.getCardOffset(a)
                            }
                        }
                        this.updateCardPositions(true)
                    },
                    onTransitionEnd : function(b, a) {
                        this.customDrag = false;
                        this.currentScroll = {
                            x : 0,
                            y : 0
                        };
                        if (this.oldCard
                                && this.layout.activeItem != this.oldCard) {
                            this.onCardSwitch(this.layout.activeItem,
                                    this.oldCard, this.items
                                            .indexOf(this.layout.activeItem),
                                    true)
                        }
                        delete this.oldCard
                    },
                    onCardSwitch : function(a, c, b, d) {
                        this.currentScroll = {
                            x : 0,
                            y : 0
                        };
                        this.updateCardPositions();
                        Ext.Carousel.superclass.onCardSwitch.apply(this,
                                arguments);
                        a.fireEvent("activate", a)
                    },
                    next : function() {
                        var a = this.layout.getNext();
                        if (a) {
                            this.customDrag = true;
                            this.scrollToCard(a)
                        }
                        return this
                    },
                    prev : function() {
                        var a = this.layout.getPrev();
                        if (a) {
                            this.customDrag = true;
                            this.scrollToCard(a)
                        }
                        return this
                    },
                    isVertical : function() {
                        return this.vertical
                    },
                    isHorizontal : function() {
                        return this.horizontal
                    },
                    beforeDestroy : function() {
                        Ext.destroy(this.indicator);
                        Ext.Carousel.superclass.beforeDestroy.call(this)
                    }
                });
Ext.reg("carousel", Ext.Carousel);
Ext.Carousel.Indicator = Ext.extend(Ext.Component, {
    baseCls : "x-carousel-indicator",
    initComponent : function() {
        if (this.carousel.rendered) {
            this.render(this.carousel.body);
            this.onBeforeCardSwitch(null, null, this.carousel.items
                    .indexOf(this.carousel.layout.getActiveItem()))
        } else {
            this.carousel.on("render", function() {
                this.render(this.carousel.body)
            }, this, {
                single : true
            })
        }
        Ext.Carousel.Indicator.superclass.initComponent.call(this)
    },
    onRender : function() {
        Ext.Carousel.Indicator.superclass.onRender.apply(this, arguments);
        for ( var a = 0, b = this.carousel.items.length; a < b; a++) {
            this.createIndicator()
        }
        this.mon(this.carousel, {
            beforecardswitch : this.onBeforeCardSwitch,
            scope : this
        });
        this.mon(this.el, {
            tap : this.onTap,
            scope : this
        });
        this.el.addCls(this.baseCls + "-" + this.direction)
    },
    onTap : function(g, a) {
        var b = this.el.getPageBox(), f = b.left + (b.width / 2), c = b.top
                + (b.height / 2), d = this.carousel;
        if ((d.isHorizontal() && g.pageX > f)
                || (d.isVertical() && g.pageY > c)) {
            this.carousel.next()
        } else {
            this.carousel.prev()
        }
    },
    createIndicator : function() {
        this.indicators = this.indicators || [];
        this.indicators.push(this.el.createChild({
            tag : "span"
        }))
    },
    onBeforeCardSwitch : function(d, c, a, b) {
        if (Ext.isNumber(b) && b != -1 && this.indicators[b]) {
            this.indicators[b].radioCls("x-carousel-indicator-active")
        }
    },
    onCardAdd : function() {
        if (this.rendered) {
            this.createIndicator()
        }
    },
    onCardRemove : function() {
        if (this.rendered) {
            this.indicators.pop().remove()
        }
    }
});
Ext.reg("carouselindicator", Ext.Carousel.Indicator);
Ext.Map = Ext
        .extend(
                Ext.Component,
                {
                    baseCls : "x-map",
                    useCurrentLocation : false,
                    monitorResize : true,
                    map : null,
                    geo : null,
                    maskMap : false,
                    maskMapCls : "x-mask-map",
                    initComponent : function() {
                        this.mapOptions = this.mapOptions || {};
                        this.scroll = false;
                        if (!(window.google || {}).maps) {
                            this.html = "Google Maps API is required"
                        } else {
                            if (this.useCurrentLocation) {
                                this.geo = this.geo
                                        || new Ext.util.GeoLocation({
                                            autoLoad : false
                                        });
                                this.geo.on({
                                    locationupdate : this.onGeoUpdate,
                                    locationerror : this.onGeoError,
                                    scope : this
                                })
                            }
                        }
                        Ext.Map.superclass.initComponent.call(this);
                        this.addEvents("maprender", "centerchange",
                                "typechange", "zoomchange");
                        if (this.geo) {
                            this.on({
                                activate : this.onUpdate,
                                scope : this,
                                single : true
                            });
                            this.geo.updateLocation()
                        }
                    },
                    onRender : function(b, a) {
                        Ext.Map.superclass.onRender.apply(this, arguments);
                        this.el.setVisibilityMode(Ext.Element.OFFSETS)
                    },
                    afterRender : function() {
                        Ext.Map.superclass.afterRender.apply(this, arguments);
                        this.renderMap()
                    },
                    onResize : function(a, b) {
                        Ext.Map.superclass.onResize.apply(this, arguments);
                        if (this.map) {
                            google.maps.event.trigger(this.map, "resize")
                        }
                    },
                    afterComponentLayout : function() {
                        if (this.maskMap && !this.mask) {
                            this.el.mask(null, this.maskMapCls);
                            this.mask = true
                        }
                    },
                    renderMap : function() {
                        var b = this, c = (window.google || {}).maps;
                        if (c) {
                            if (Ext.is.iPad) {
                                Ext
                                        .applyIf(
                                                b.mapOptions,
                                                {
                                                    navigationControlOptions : {
                                                        style : c.NavigationControlStyle.ZOOM_PAN
                                                    }
                                                })
                            }
                            Ext.applyIf(b.mapOptions, {
                                center : new c.LatLng(37.381592, -122.135672),
                                zoom : 12,
                                mapTypeId : c.MapTypeId.ROADMAP
                            });
                            if (b.maskMap && !b.mask) {
                                b.el.mask(null, this.maskMapCls);
                                b.mask = true
                            }
                            if (b.el && b.el.dom && b.el.dom.firstChild) {
                                Ext.fly(b.el.dom.firstChild).remove()
                            }
                            if (b.map) {
                                c.event.clearInstanceListeners(b.map)
                            }
                            b.map = new c.Map(b.el.dom, b.mapOptions);
                            var a = c.event;
                            a.addListener(b.map, "zoom_changed", Ext
                                    .createDelegate(b.onZoom, b));
                            a.addListener(b.map, "maptypeid_changed", Ext
                                    .createDelegate(b.onTypeChange, b));
                            a.addListener(b.map, "center_changed", Ext
                                    .createDelegate(b.onCenterChange, b));
                            b.fireEvent("maprender", b, b.map)
                        }
                    },
                    onGeoUpdate : function(b) {
                        var a;
                        if (b) {
                            a = this.mapOptions.center = new google.maps.LatLng(
                                    b.latitude, b.longitude)
                        }
                        if (this.rendered) {
                            this.update(a)
                        } else {
                            this.on("activate", this.onUpdate, this, {
                                single : true,
                                data : a
                            })
                        }
                    },
                    onGeoError : function(a) {
                    },
                    onUpdate : function(c, b, a) {
                        this.update((a || {}).data)
                    },
                    update : function(c) {
                        var a = this, b = (window.google || {}).maps;
                        if (b) {
                            c = c || a.coords
                                    || new b.LatLng(37.381592, -122.135672);
                            if (c && !(c instanceof b.LatLng)
                                    && "longitude" in c) {
                                c = new b.LatLng(c.latitude, c.longitude)
                            }
                            if (!a.hidden && a.rendered) {
                                a.map || a.renderMap();
                                if (a.map && c instanceof b.LatLng) {
                                    a.map.panTo(c)
                                }
                            } else {
                                a.on("activate", a.onUpdate, a, {
                                    single : true,
                                    data : c
                                })
                            }
                        }
                    },
                    onZoom : function() {
                        this.mapOptions.zoom = (this.map && this.map.getZoom ? this.map
                                .getZoom()
                                : this.mapOptions.zoom) || 10;
                        this.fireEvent("zoomchange", this, this.map,
                                this.mapOptions.zoom)
                    },
                    onTypeChange : function() {
                        this.mapOptions.mapTypeId = this.map
                                && this.map.getMapTypeId ? this.map
                                .getMapTypeId() : this.mapOptions.mapTypeId;
                        this.fireEvent("typechange", this, this.map,
                                this.mapOptions.mapTypeId)
                    },
                    onCenterChange : function() {
                        this.mapOptions.center = this.map && this.map.getCenter ? this.map
                                .getCenter()
                                : this.mapOptions.center;
                        this.fireEvent("centerchange", this, this.map,
                                this.mapOptions.center)
                    },
                    getState : function() {
                        return this.mapOptions
                    },
                    onDestroy : function() {
                        Ext.destroy(this.geo);
                        if (this.maskMap && this.mask) {
                            this.el.unmask()
                        }
                        if (this.map && (window.google || {}).maps) {
                            google.maps.event.clearInstanceListeners(this.map)
                        }
                        Ext.Map.superclass.onDestroy.call(this)
                    }
                });
Ext.reg("map", Ext.Map);
Ext.NestedList = Ext
        .extend(
                Ext.Panel,
                {
                    componentCls : "x-nested-list",
                    layout : "card",
                    cardSwitchAnimation : "slide",
                    backButton : null,
                    backText : "Back",
                    useTitleAsBackText : true,
                    updateTitleText : true,
                    displayField : "text",
                    loadingText : "Loading...",
                    emptyText : "No items available.",
                    onItemDisclosure : false,
                    clearSelectionDelay : 200,
                    allowDeselect : false,
                    getItemTextTpl : function(a) {
                        return "{" + this.displayField + "}"
                    },
                    getTitleTextTpl : function(a) {
                        return "{" + this.displayField + "}"
                    },
                    renderTitleText : function(b) {
                        if (!b.titleTpl) {
                            b.titleTpl = new Ext.XTemplate(this
                                    .getTitleTextTpl(b))
                        }
                        var a = b.getRecord();
                        if (a) {
                            return b.titleTpl.applyTemplate(a.data)
                        } else {
                            if (b.isRoot) {
                                return this.title || this.backText
                            } else {
                                throw new Error(
                                        "No RecordNode passed into renderTitleText")
                            }
                        }
                    },
                    useToolbar : true,
                    getDetailCard : function(b, a) {
                        return false
                    },
                    initComponent : function() {
                        var b = Ext.StoreMgr.lookup(this.store), a = b
                                .getRootNode(), c = a.getRecord() ? this
                                .renderTitleText(a) : this.title || "";
                        this.store = b;
                        if (this.useToolbar) {
                            this.backButton = new Ext.Button({
                                text : this.backText,
                                ui : "back",
                                handler : this.onBackTap,
                                scope : this,
                                hidden : true
                            });
                            if (!this.toolbar || !this.toolbar.isComponent) {
                                this.toolbar = Ext.apply({},
                                        this.toolbar || {}, {
                                            dock : "top",
                                            xtype : "toolbar",
                                            ui : "light",
                                            title : c,
                                            items : []
                                        });
                                this.toolbar.items.unshift(this.backButton);
                                this.toolbar = new Ext.Toolbar(this.toolbar);
                                this.dockedItems = this.dockedItems || [];
                                this.dockedItems.push(this.toolbar)
                            } else {
                                this.toolbar.insert(0, this.backButton)
                            }
                        }
                        this.items = [ this.getSubList(a) ];
                        Ext.NestedList.superclass.initComponent.call(this);
                        this.on("itemtap", this.onItemTap, this);
                        this.addEvents("listchange", "leafitemtap")
                    },
                    getListConfig : function(b) {
                        var c = b.internalId, a = this.emptyText;
                        return {
                            itemId : c,
                            xtype : "list",
                            autoDestroy : true,
                            recordNode : b,
                            store : this.store.getSubStore(b),
                            loadingText : this.loadingText,
                            onItemDisclosure : this.onItemDisclosure,
                            displayField : this.displayField,
                            singleSelect : true,
                            clearSelectionOnDeactivate : false,
                            bubbleEvents : [ "itemtap", "containertap",
                                    "beforeselect", "itemdoubletap",
                                    "selectionchange" ],
                            itemTpl : '<span<tpl if="leaf == true"> class="x-list-item-leaf"</tpl>>'
                                    + this.getItemTextTpl(b) + "</span>",
                            deferEmptyText : true,
                            allowDeselect : this.allowDeselect,
                            refresh : function() {
                                if (this.hasSkippedEmptyText) {
                                    this.emptyText = a
                                }
                                Ext.List.prototype.refresh.apply(this,
                                        arguments)
                            }
                        }
                    },
                    getSubList : function(b) {
                        var a = this.items, c, d = b.internalId;
                        if (a && a.get) {
                            c = a.get(d)
                        }
                        if (c) {
                            return c
                        } else {
                            return this.getListConfig(b)
                        }
                    },
                    addNextCard : function(b, e) {
                        var c, a = b ? b.parentNode : null, d;
                        if (b.leaf) {
                            d = this.getDetailCard(b, a);
                            if (d) {
                                c = this.add(d)
                            }
                        } else {
                            c = this.getSubList(b);
                            c = this.add(c)
                        }
                        return c
                    },
                    setActivePath : function(o) {
                        var n = o.substr(0, 1) === "/", h = 0, e = this.store, p = e.tree, f, g, c, m, b;
                        if (n) {
                            o = o.substr(1)
                        }
                        m = Ext.toArray(o.split("/"));
                        b = m.length;
                        if (n) {
                            var l = this.items, a = this.items.items, k = l.length;
                            for (; k > 1; k--) {
                                this.remove(a[k - 1], true)
                            }
                            var d = a[0].recordNode;
                            if (d.id !== m[0]) {
                                throw new Error("rootNode doesn't match!")
                            }
                            h = 1
                        }
                        for (; h < b; h++) {
                            if (m[h] !== "") {
                                f = p.getNodeById(m[h]);
                                g = this.addNextCard(f);
                                if (g) {
                                    c = g
                                }
                            }
                        }
                        if (!c) {
                            throw new Error(
                                    "Card was not found when trying to add to NestedList.")
                        }
                        this.setActiveItem(c, false);
                        this.fireEvent("listchange", this, c);
                        this.syncToolbar()
                    },
                    syncToolbar : function(e) {
                        var g = e || this.getActiveItem(), h = this.items
                                .indexOf(g), b = g.recordNode, a = b ? b.parentNode
                                : null, d = this.backButton, c = this.useTitleAsBackText
                                && a ? this.renderTitleText(a) : this.backText, f = (h !== 0) ? "show"
                                : "hide";
                        if (d) {
                            d[f]();
                            if (a) {
                                d.setText(c)
                            }
                        }
                        if (this.toolbar && this.updateTitleText) {
                            this.toolbar.setTitle(b && b.getRecord() ? this
                                    .renderTitleText(b) : this.title || "");
                            this.toolbar.doLayout()
                        }
                    },
                    onItemTap : function(l, d, a, i) {
                        var k = l.getStore(), f = k.getAt(d), m = f.node, g = m ? m.parentNode
                                : null, h = this.displayField, c, b, j;
                        j = this.addNextCard(m);
                        if (m.leaf) {
                            this.fireEvent("leafitemtap", l, d, a, i, j)
                        }
                        if (j) {
                            b = this.items.indexOf(j);
                            this.setActiveItem(j, {
                                type : this.cardSwitchAnimation
                            });
                            this.syncToolbar(j)
                        }
                    },
                    onBackTap : function() {
                        var g = this.getActiveItem(), h = this.items.indexOf(g);
                        if (h != 0) {
                            var a = h - 1, c = this.items.getAt(a), j = c.recordNode, d = j
                                    .getRecord(), e = j ? j.parentNode : null, f = this.backButton, b = (a !== 0) ? "show"
                                    : "hide", i;
                            this.on("cardswitch", function(k, m) {
                                var l = c.getSelectionModel();
                                this.remove(g);
                                if (this.clearSelectionDelay) {
                                    Ext.defer(l.deselectAll,
                                            this.clearSelectionDelay, l)
                                }
                            }, this, {
                                single : true
                            });
                            this.setActiveItem(c, {
                                type : this.cardSwitchAnimation,
                                reverse : true,
                                scope : this
                            });
                            this.syncToolbar(c)
                        }
                    }
                });
Ext.reg("nestedlist", Ext.NestedList);
Ext.Picker = Ext.extend(Ext.Sheet, {
    componentCls : "x-picker",
    stretchX : true,
    stretchY : true,
    hideOnMaskTap : false,
    doneButton : "Done",
    cancelButton : "Cancel",
    height : 220,
    useTitles : false,
    defaultType : "pickerslot",
    initComponent : function() {
        this.addEvents("pick", "change", "cancel");
        this.layout = {
            type : "hbox",
            align : "stretch"
        };
        if (this.slots) {
            this.items = this.items ? (Ext.isArray(this.items) ? this.items
                    : [ this.items ]) : [];
            this.items = this.items.concat(this.slots)
        }
        if (this.useTitles) {
            this.defaults = Ext.applyIf(this.defaults || {}, {
                title : ""
            })
        }
        this.on("slotpick", this.onSlotPick, this);
        if (this.doneButton || this.cancelButton) {
            var a = [];
            if (this.cancelButton) {
                a.push(Ext.apply({
                    handler : this.onCancelButtonTap,
                    scope : this
                }, ((Ext.isObject(this.cancelButton) ? this.cancelButton : {
                    text : String(this.cancelButton)
                }))))
            }
            a.push({
                xtype : "spacer"
            });
            if (this.doneButton) {
                a.push(Ext.apply({
                    ui : "action",
                    handler : this.onDoneButtonTap,
                    scope : this
                }, ((Ext.isObject(this.doneButton) ? this.doneButton : {
                    text : String(this.doneButton)
                }))))
            }
            this.toolbar = new Ext.Toolbar(Ext.applyIf(this.buttonBar || {
                dock : "top",
                items : a,
                defaults : {
                    xtype : "button"
                }
            }));
            this.dockedItems = this.dockedItems ? (Ext
                    .isArray(this.dockedItems) ? this.dockedItems
                    : [ this.dockedItems ]) : [];
            this.dockedItems.push(this.toolbar)
        }
        Ext.Picker.superclass.initComponent.call(this)
    },
    afterRender : function() {
        Ext.Picker.superclass.afterRender.apply(this, arguments);
        if (this.value) {
            this.setValue(this.value, false)
        }
    },
    onDoneButtonTap : function() {
        var a = this.animSheet("exit");
        Ext.apply(a, {
            after : function() {
                this.fireEvent("change", this, this.getValue())
            },
            scope : this
        });
        this.hide(a)
    },
    onCancelButtonTap : function() {
        var a = this.animSheet("exit");
        Ext.apply(a, {
            after : function() {
                this.setValue(this.values);
                this.fireEvent("cancel", this)
            },
            scope : this
        });
        this.hide(a)
    },
    onSlotPick : function(c, b, a) {
        this.fireEvent("pick", this, this.getValue(), c);
        return false
    },
    setValue : function(b, e) {
        var f, a = this.items.items, d = a.length;
        if (!b) {
            for ( var c = 0; c < d; c++) {
                a[c].setSelectedNode(0)
            }
            return this
        }
        Ext.iterate(b, function(g, h) {
            f = this.child("[name=" + g + "]");
            if (f) {
                f.setValue(h, e)
            }
        }, this);
        this.values = b;
        return this
    },
    getValue : function() {
        var b = {}, a = this.items.items, e = a.length, d, c;
        for (c = 0; c < e; c++) {
            d = a[c];
            b[d.name] = d.getValue()
        }
        return b
    }
});
Ext.regModel("x-textvalue", {
    fields : [ "text", "value" ]
});
Ext.Picker.Slot = Ext.extend(Ext.DataView, {
    isSlot : true,
    flex : 1,
    name : null,
    displayField : "text",
    valueField : "value",
    align : "center",
    itemSelector : "div.x-picker-item",
    componentCls : "x-picker-slot",
    renderTpl : [ '<div class="x-picker-mask">',
            '<div class="x-picker-bar"></div>', "</div>" ],
    selectedIndex : 0,
    getElConfig : function() {
        return {
            tag : "div",
            id : this.id,
            cls : "x-picker-" + this.align
        }
    },
    initComponent : function() {
        if (!this.name) {
            throw new Error("Each picker slot is required to have a name.")
        }
        Ext.apply(this.renderSelectors, {
            mask : ".x-picker-mask",
            bar : ".x-picker-bar"
        });
        this.scroll = {
            direction : "vertical",
            useIndicators : false,
            friction : 0.7,
            acceleration : 25,
            snapDuration : 200,
            animationDuration : 200
        };
        this.tpl = new Ext.XTemplate([
                '<tpl for=".">',
                '<div class="x-picker-item {cls} <tpl if="extra">x-picker-invalid</tpl>">{'
                        + this.displayField + "}</div>", "</tpl>" ]);
        var d = this.data, f = [], c = d && d.length, a, b, e;
        if (d && Ext.isArray(d) && c) {
            for (a = 0; a < c; a++) {
                b = d[a];
                e = {};
                if (Ext.isArray(b)) {
                    e[this.valueField] = b[0];
                    e[this.displayField] = b[1]
                } else {
                    if (Ext.isString(b)) {
                        e[this.valueField] = b;
                        e[this.displayField] = b
                    } else {
                        if (Ext.isObject(b)) {
                            e = b
                        }
                    }
                }
                f.push(e)
            }
            this.store = new Ext.data.Store({
                model : "x-textvalue",
                data : f
            });
            this.tempStore = true
        } else {
            if (this.store) {
                this.store = Ext.StoreMgr.lookup(this.store)
            }
        }
        this.enableBubble("slotpick");
        if (this.title) {
            this.title = new Ext.Component({
                dock : "top",
                componentCls : "x-picker-slot-title",
                html : this.title
            });
            this.dockedItems = this.title
        }
        Ext.Picker.Slot.superclass.initComponent.call(this);
        if (this.value !== undefined) {
            this.setValue(this.value, false)
        }
    },
    setupBar : function() {
        this.el.setStyle({
            padding : ""
        });
        var a = this.bar.getY() - this.el.getY();
        this.barHeight = this.bar.getHeight();
        this.el.setStyle({
            padding : a + "px 0"
        });
        this.slotPadding = a;
        this.scroller.updateBoundary();
        this.scroller.setSnap(this.barHeight);
        this.setSelectedNode(this.selectedIndex, false)
    },
    afterComponentLayout : function() {
        Ext.defer(this.setupBar, 200, this)
    },
    initEvents : function() {
        this.mon(this.scroller, {
            scrollend : this.onScrollEnd,
            scope : this
        })
    },
    onScrollEnd : function(a, b) {
        this.selectedNode = this.getNode(Math.round(b.y / this.barHeight));
        this.selectedIndex = this.indexOf(this.selectedNode);
        this.fireEvent("slotpick", this, this.getValue(), this.selectedNode)
    },
    scrollToNode : function(c, a) {
        var b = Ext.fly(c).getOffsetsTo(this.scrollEl)[1];
        this.scroller.scrollTo({
            y : b
        }, a !== false ? true : false)
    },
    onItemTap : function(a) {
        Ext.Picker.Slot.superclass.onItemTap.apply(this, arguments);
        this.setSelectedNode(a);
        this.selectedNode = a;
        this.selectedIndex = this.indexOf(a);
        this.fireEvent("slotpick", this, this.getValue(), this.selectedNode)
    },
    getSelectedNode : function() {
        return this.selectedNode
    },
    setSelectedNode : function(b, a) {
        if (Ext.isNumber(b)) {
            b = this.getNode(b)
        } else {
            if (b.isModel) {
                b = this.getNode(this.store.indexOf(b))
            }
        }
        if (b) {
            this.selectedNode = b;
            this.selectedIndex = this.indexOf(b);
            this.scrollToNode(b, a)
        }
    },
    getValue : function() {
        var a = this.store.getAt(this.selectedIndex);
        return a ? a.get(this.valueField) : null
    },
    setValue : function(c, a) {
        var b = this.store.find(this.valueField, c);
        if (b != -1) {
            if (!this.rendered) {
                this.selectedIndex = b;
                return
            }
            this.setSelectedNode(b, a)
        }
    },
    onDestroy : function() {
        if (this.tempStore) {
            this.store.destroyStore();
            this.store = null
        }
        Ext.Picker.Slot.superclass.onDestroy.call(this)
    }
});
Ext.reg("pickerslot", Ext.Picker.Slot);
Ext.DatePicker = Ext
        .extend(
                Ext.Picker,
                {
                    yearFrom : 1980,
                    yearTo : new Date().getFullYear(),
                    monthText : "Month",
                    dayText : "Day",
                    yearText : "Year",
                    slotOrder : [ "month", "day", "year" ],
                    initComponent : function() {
                        var j = this.yearFrom, e = this.yearTo, f = [], h = [], b = [], g, c, d, a;
                        if (j > e) {
                            c = j;
                            j = e;
                            e = c
                        }
                        for (d = j; d <= e; d++) {
                            f.push({
                                text : d,
                                value : d
                            })
                        }
                        a = this.getDaysInMonth(1, new Date().getFullYear());
                        for (d = 0; d < a; d++) {
                            h.push({
                                text : d + 1,
                                value : d + 1
                            })
                        }
                        for (d = 0, g = Date.monthNames.length; d < g; d++) {
                            b.push({
                                text : Date.monthNames[d],
                                value : d + 1
                            })
                        }
                        this.slots = [];
                        this.slotOrder.forEach(function(i) {
                            this.slots.push(this.createSlot(i, h, b, f))
                        }, this);
                        Ext.DatePicker.superclass.initComponent.call(this)
                    },
                    afterRender : function() {
                        Ext.DatePicker.superclass.afterRender.apply(this,
                                arguments);
                        this.setValue(this.value)
                    },
                    createSlot : function(b, d, a, c) {
                        switch (b) {
                        case "year":
                            return {
                                name : "year",
                                align : "center",
                                data : c,
                                title : this.useTitles ? this.yearText : false,
                                flex : 3
                            };
                        case "month":
                            return {
                                name : b,
                                align : "right",
                                data : a,
                                title : this.useTitles ? this.monthText : false,
                                flex : 4
                            };
                        case "day":
                            return {
                                name : "day",
                                align : "center",
                                data : d,
                                title : this.useTitles ? this.dayText : false,
                                flex : 2
                            }
                        }
                    },
                    onSlotPick : function(f, e) {
                        var c = f.name, b, a, d;
                        if (c === "month" || c === "year") {
                            d = this.child("[name=day]");
                            b = this.getValue();
                            a = this.getDaysInMonth(b.getMonth() + 1, b
                                    .getFullYear());
                            d.store.clearFilter();
                            d.store.filter({
                                fn : function(g) {
                                    return g.get("extra") === true
                                            || g.get("value") <= a
                                }
                            });
                            d.scroller.updateBoundary(true)
                        }
                        Ext.DatePicker.superclass.onSlotPick.apply(this,
                                arguments)
                    },
                    getValue : function() {
                        var c = Ext.DatePicker.superclass.getValue.call(this), b = this
                                .getDaysInMonth(c.month, c.year), a = Math.min(
                                c.day, b);
                        return new Date(c.year, c.month - 1, a)
                    },
                    setValue : function(b, a) {
                        if (!Ext.isDate(b) && !Ext.isObject(b)) {
                            b = null
                        }
                        if (Ext.isDate(b)) {
                            this.value = {
                                day : b.getDate(),
                                year : b.getFullYear(),
                                month : b.getMonth() + 1
                            }
                        } else {
                            this.value = b
                        }
                        return Ext.DatePicker.superclass.setValue.call(this,
                                this.value, a)
                    },
                    getDaysInMonth : function(c, b) {
                        var a = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,
                                31 ];
                        return c == 2 && this.isLeapYear(b) ? 29 : a[c - 1]
                    },
                    isLeapYear : function(a) {
                        return !!((a & 3) === 0 && (a % 100 || (a % 400 === 0 && a)))
                    }
                });
Ext.reg("datepicker", Ext.DatePicker);
Ext.Media = Ext.extend(Ext.Component, {
    url : "",
    enableControls : true,
    autoResume : false,
    autoPause : true,
    preload : true,
    playing : false,
    afterRender : function() {
        var a = this.getConfiguration();
        Ext.apply(a, {
            src : this.url,
            preload : this.preload ? "auto" : "none"
        });
        if (this.enableControls) {
            a.controls = "controls"
        }
        if (this.loop) {
            a.loop = "loop"
        }
        this.media = this.el.createChild(a);
        Ext.Media.superclass.afterRender.call(this);
        this.on({
            scope : this,
            activate : this.onActivate,
            beforedeactivate : this.onDeactivate
        })
    },
    onActivate : function() {
        if (this.autoResume && !this.playing) {
            this.play()
        }
    },
    onDeactivate : function() {
        if (this.autoPause && this.playing) {
            this.pause()
        }
    },
    play : function() {
        this.media.dom.play();
        this.playing = true
    },
    pause : function() {
        this.media.dom.pause();
        this.playing = false
    },
    toggle : function() {
        if (this.playing) {
            this.pause()
        } else {
            this.play()
        }
    }
});
Ext.reg("media", Ext.Media);
Ext.Video = Ext
        .extend(
                Ext.Media,
                {
                    posterUrl : "",
                    componentCls : "x-video",
                    afterRender : function() {
                        Ext.Video.superclass.afterRender.call(this);
                        if (this.posterUrl) {
                            this.media.hide();
                            this.ghost = this.el
                                    .createChild({
                                        cls : "x-video-ghost",
                                        style : "width: 100%; height: 100%; background: #000 url("
                                                + this.posterUrl
                                                + ") center center no-repeat; -webkit-background-size: 100% auto;"
                                    });
                            this.ghost.on("tap", this.onGhostTap, this, {
                                single : true
                            })
                        }
                    },
                    onGhostTap : function() {
                        this.media.show();
                        this.ghost.hide();
                        this.play()
                    },
                    getConfiguration : function() {
                        return {
                            tag : "video",
                            width : "100%",
                            height : "100%"
                        }
                    }
                });
Ext.reg("video", Ext.Video);
Ext.Audio = Ext.extend(Ext.Media, {
    componentCls : "x-audio",
    onActivate : function() {
        Ext.Audio.superclass.onActivate.call(this);
        if (Ext.is.Phone) {
            this.media.show()
        }
    },
    onDeactivate : function() {
        Ext.Audio.superclass.onDeactivate.call(this);
        if (Ext.is.Phone) {
            this.media.hide()
        }
    },
    getConfiguration : function() {
        var a = !this.enableControls;
        if (!Ext.supports.AudioTag) {
            return {
                tag : "embed",
                type : "audio/mpeg",
                target : "myself",
                controls : "true",
                hidden : a
            }
        } else {
            return {
                tag : "audio",
                hidden : a
            }
        }
    }
});
Ext.reg("audio", Ext.Audio);
Ext.MessageBox = Ext
        .extend(
                Ext.Sheet,
                {
                    centered : true,
                    renderHidden : true,
                    ui : "dark",
                    componentCls : "x-msgbox",
                    enterAnimation : "pop",
                    exitAnimation : "pop",
                    autoHeight : true,
                    defaultTextHeight : 75,
                    constructor : function(a) {
                        a = a || {};
                        var c = a.ui || this.ui || "", b = a.componentCls
                                || this.componentCls;
                        delete a.html;
                        this.titleBar = Ext.create({
                            xtype : "toolbar",
                            ui : c,
                            dock : "top",
                            cls : b + "-title",
                            title : "&#160;"
                        });
                        this.buttonBar = Ext.create({
                            xtype : "toolbar",
                            ui : c,
                            dock : "bottom",
                            layout : {
                                pack : "center"
                            },
                            cls : b + "-buttons"
                        });
                        a = Ext.apply({
                            ui : c,
                            dockedItems : [ this.titleBar, this.buttonBar ],
                            renderSelectors : {
                                body : "." + b + "-body",
                                iconEl : "." + b + "-icon",
                                msgContentEl : "." + b + "-content",
                                msgEl : "." + b + "-text",
                                inputsEl : "." + b + "-inputs",
                                inputEl : "." + b + "-input-single",
                                multiLineEl : "." + b + "-input-textarea"
                            }
                        }, a || {});
                        Ext.MessageBox.superclass.constructor.call(this, a)
                    },
                    renderTpl : [
                            '<div class="{componentCls}-body"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',
                            '<div class="{componentCls}-icon x-hidden-display"></div>',
                            '<div class="{componentCls}-content">',
                            '<div class="{componentCls}-text"></div>',
                            '<div class="{componentCls}-inputs x-hidden-display">',
                            '<input type="text" class="{componentCls}-input {componentCls}-input-single" />',
                            '<textarea class="{componentCls}-input {componentCls}-input-textarea"></textarea>',
                            "</div>", "</div>", "</div>" ],
                    onClick : function(b) {
                        if (b) {
                            var a = b.config || {};
                            if (typeof a.fn == "function") {
                                a.fn.call(a.scope || null, b.itemId || b.text,
                                        a.input ? a.input.dom.value : null, a)
                            }
                            if (a.cls) {
                                this.el.removeCls(a.cls)
                            }
                            if (a.input) {
                                a.input.dom.blur()
                            }
                        }
                        this.hide()
                    },
                    show : function(c) {
                        var e, d, g = {
                            autocomplete : "off",
                            autocapitalize : "off",
                            autocorrect : "off",
                            maxlength : 0,
                            autofocus : true,
                            placeholder : "",
                            type : "text"
                        }, a = /true|on/i;
                        this.rendered || this.render(document.body);
                        c = Ext.applyIf(c || {}, {
                            multiLine : false,
                            prompt : false,
                            value : "",
                            modal : true
                        });
                        if (c.title) {
                            this.titleBar.setTitle(c.title);
                            this.titleBar.show()
                        } else {
                            this.titleBar.hide()
                        }
                        if (this.inputsEl && (c.multiLine || c.prompt)) {
                            this.inputsEl.show();
                            if (this.multiLineEl && c.multiLine) {
                                this.inputEl && this.inputEl.hide();
                                this.multiLineEl
                                        .show()
                                        .setHeight(
                                                Ext.isNumber(c.multiLine) ? parseFloat(c.multiLine)
                                                        : this.defaultTextHeight);
                                c.input = this.multiLineEl
                            } else {
                                if (this.inputEl) {
                                    this.inputEl.show();
                                    this.multiLineEl && this.multiLineEl.hide();
                                    c.input = this.inputEl
                                }
                            }
                            if (Ext.isObject(c.prompt)) {
                                Ext.apply(g, c.prompt)
                            }
                            for (d in g) {
                                if (g.hasOwnProperty(d)) {
                                    e = g[d];
                                    c.input.dom
                                            .setAttribute(
                                                    d.toLowerCase(),
                                                    /^auto/i.test(d) ? (a
                                                            .test(e + "") ? "on"
                                                            : "off")
                                                            : e)
                                }
                            }
                        } else {
                            this.inputsEl && this.inputsEl.hide()
                        }
                        this.setIcon(c.icon || "", false);
                        this.updateText(c.msg, false);
                        if (c.cls) {
                            this.el.addCls(c.cls)
                        }
                        this.modal = !!c.modal;
                        var f = this.buttonBar, b = [];
                        f.removeAll();
                        Ext.each([].concat(c.buttons || Ext.MessageBox.OK),
                                function(h) {
                                    if (h) {
                                        b.push(Ext.applyIf({
                                            config : c,
                                            scope : this,
                                            handler : this.onClick
                                        }, h))
                                    }
                                }, this);
                        f.add(b);
                        if (f.rendered) {
                            f.doLayout()
                        }
                        Ext.MessageBox.superclass.show.call(this, c.animate);
                        if (c.input) {
                            c.input.dom.value = c.value || "";
                            if (a.test(g.autofocus + "")
                                    && !("autofocus" in c.input.dom)) {
                                c.input.dom.focus()
                            }
                        }
                        return this
                    },
                    onOrientationChange : function() {
                        this.doComponentLayout();
                        Ext.MessageBox.superclass.onOrientationChange.apply(
                                this, arguments)
                    },
                    adjustScale : function() {
                        Ext.apply(this, {
                            maxWidth : window.innerWidth,
                            maxHeight : window.innerHeight,
                            minWidth : window.innerWidth * 0.5,
                            minHeight : window.innerHeight * 0.5
                        })
                    },
                    doComponentLayout : function() {
                        this.adjustScale();
                        return Ext.MessageBox.superclass.doComponentLayout
                                .apply(this, arguments)
                    },
                    alert : function(d, c, b, a) {
                        return this.show({
                            title : d,
                            msg : c,
                            buttons : Ext.MessageBox.OK,
                            fn : b,
                            scope : a,
                            icon : Ext.MessageBox.INFO
                        })
                    },
                    confirm : function(d, c, b, a) {
                        return this.show({
                            title : d,
                            msg : c,
                            buttons : Ext.MessageBox.YESNO,
                            fn : function(e) {
                                b.call(a, e)
                            },
                            scope : a,
                            icon : Ext.MessageBox.QUESTION
                        })
                    },
                    prompt : function(g, f, c, b, e, d, a) {
                        return this.show({
                            title : g,
                            msg : f,
                            buttons : Ext.MessageBox.OKCANCEL,
                            fn : function(i, h) {
                                c.call(b, i, h)
                            },
                            scope : b,
                            icon : Ext.MessageBox.QUESTION,
                            prompt : a || true,
                            multiLine : e,
                            value : d
                        })
                    },
                    updateText : function(b, a) {
                        if (this.msgEl) {
                            this.msgEl.update(b ? String(b) : "&#160;");
                            if (a !== false) {
                                this.doComponentLayout()
                            }
                        }
                        return this
                    },
                    setIcon : function(a, b) {
                        if (a) {
                            this.iconEl.show();
                            this.iconEl.replaceCls(this.iconCls, a)
                        } else {
                            this.iconEl.replaceCls(this.iconCls,
                                    "x-hidden-display")
                        }
                        if (b !== false) {
                            this.doComponentLayout()
                        }
                        this.iconCls = a;
                        return this
                    }
                });
(function() {
    var a = Ext.MessageBox;
    Ext.apply(a, {
        OK : {
            text : "OK",
            itemId : "ok",
            ui : "action"
        },
        CANCEL : {
            text : "Cancel",
            itemId : "cancel"
        },
        YES : {
            text : "Yes",
            itemId : "yes",
            ui : "action"
        },
        NO : {
            text : "No",
            itemId : "no"
        },
        INFO : "x-msgbox-info",
        WARNING : "x-msgbox-warning",
        QUESTION : "x-msgbox-question",
        ERROR : "x-msgbox-error"
    });
    Ext.apply(a, {
        OKCANCEL : [ a.CANCEL, a.OK ],
        YESNOCANCEL : [ a.CANCEL, a.NO, a.YES ],
        YESNO : [ a.NO, a.YES ]
    })
})();
Ext.reg("messagebox", Ext.MessageBox);
Ext.reg("msgbox", Ext.MessageBox);
Ext.Msg = new Ext.MessageBox();
Ext.form.FormPanel = Ext
        .extend(
                Ext.Panel,
                {
                    standardSubmit : false,
                    componentCls : "x-form",
                    url : undefined,
                    baseParams : undefined,
                    waitTpl : new Ext.XTemplate(
                            '<div class="{cls}">{message}&hellip;</div>'),
                    submitOnAction : true,
                    getElConfig : function() {
                        return Ext.apply(
                                Ext.form.FormPanel.superclass.getElConfig
                                        .call(this), {
                                    tag : "form"
                                })
                    },
                    initComponent : function() {
                        this.addEvents("submit", "beforesubmit", "exception");
                        Ext.form.FormPanel.superclass.initComponent.call(this);
                        this.on("action", this.onFieldAction, this)
                    },
                    afterRender : function() {
                        Ext.form.FormPanel.superclass.afterRender.call(this);
                        this.el.on("submit", this.onSubmit, this)
                    },
                    onSubmit : function(b, a) {
                        if (!this.standardSubmit
                                || this.fireEvent("beforesubmit", this, this
                                        .getValues(true)) === false) {
                            if (b) {
                                b.stopEvent()
                            }
                        }
                    },
                    onFieldAction : function(a) {
                        if (this.submitOnAction) {
                            a.blur();
                            this.submit()
                        }
                    },
                    submit : function(a) {
                        var b = this.el.dom || {}, c;
                        a = Ext.apply({
                            url : this.url || b.action,
                            submitDisabled : false,
                            method : b.method || "post",
                            autoAbort : false,
                            params : null,
                            waitMsg : null,
                            headers : null,
                            success : null,
                            failure : null
                        }, a || {});
                        c = this.getValues(this.standardSubmit
                                || !a.submitDisabled);
                        if (this.standardSubmit) {
                            if (b) {
                                if (a.url && Ext.isEmpty(b.action)) {
                                    b.action = a.url
                                }
                                b.method = (a.method || b.method).toLowerCase();
                                if (this.fireEvent("beforesubmit", this, c, a) !== false) {
                                    b.submit()
                                }
                            }
                            return null
                        }
                        if (this.fireEvent("beforesubmit", this, c, a) !== false) {
                            if (a.waitMsg) {
                                this.showMask(a.waitMsg)
                            }
                            return Ext.Ajax
                                    .request({
                                        url : a.url,
                                        method : a.method,
                                        rawData : Ext.urlEncode(Ext.apply(Ext
                                                .apply({}, this.baseParams
                                                        || {}), a.params || {},
                                                c)),
                                        autoAbort : a.autoAbort,
                                        headers : Ext
                                                .apply(
                                                        {
                                                            "Content-Type" : "application/x-www-form-urlencoded; charset=UTF-8"
                                                        }, a.headers || {}),
                                        scope : this,
                                        callback : function(d, g, e) {
                                            var f = e.responseText;
                                            this.hideMask();
                                            if (g) {
                                                e = Ext.decode(f);
                                                g = !!e.success;
                                                if (g) {
                                                    if (Ext
                                                            .isFunction(a.success)) {
                                                        a.success.call(a.scope
                                                                || this, this,
                                                                e, f)
                                                    }
                                                    this.fireEvent("submit",
                                                            this, e);
                                                    return
                                                }
                                            }
                                            if (Ext.isFunction(a.failure)) {
                                                a.failure.call(a.scope || this,
                                                        this, e, f)
                                            }
                                            this
                                                    .fireEvent("exception",
                                                            this, e)
                                        }
                                    })
                        }
                    },
                    loadRecord : function(a) {
                        if (a && a.data) {
                            this.setValues(a.data);
                            this.record = a
                        }
                        return this
                    },
                    loadModel : function() {
                        return this.loadRecord.apply(this, arguments)
                    },
                    getRecord : function() {
                        return this.record
                    },
                    updateRecord : function(b, e) {
                        var a, c, d;
                        if (b && (a = b.fields)) {
                            c = this.getValues(e);
                            for (d in c) {
                                if (c.hasOwnProperty(d) && a.containsKey(d)) {
                                    b.set(d, c[d])
                                }
                            }
                        }
                        return this
                    },
                    setValues : function(b) {
                        var a = this.getFields(), c, e, d;
                        b = b || {};
                        for (c in b) {
                            if (b.hasOwnProperty(c)) {
                                e = a[c];
                                d = b[c];
                                if (e) {
                                    if (Ext.isArray(e)) {
                                        e.forEach(function(f) {
                                            if (Ext.isArray(b[c])) {
                                                f.setChecked((d.indexOf(f
                                                        .getValue()) != -1))
                                            } else {
                                                f
                                                        .setChecked((d == f
                                                                .getValue()))
                                            }
                                        })
                                    } else {
                                        if (e.setChecked) {
                                            e.setChecked(d)
                                        } else {
                                            e.setValue(d)
                                        }
                                    }
                                }
                            }
                        }
                        return this
                    },
                    getValues : function(d) {
                        var a = this.getFields(), e, b = {}, c;
                        for (c in a) {
                            if (a.hasOwnProperty(c)) {
                                if (Ext.isArray(a[c])) {
                                    b[c] = [];
                                    a[c]
                                            .forEach(function(f) {
                                                if (f.isChecked()
                                                        && !(d && f.disabled)) {
                                                    if (f instanceof Ext.form.Radio) {
                                                        b[c] = f.getValue()
                                                    } else {
                                                        b[c].push(f.getValue())
                                                    }
                                                }
                                            })
                                } else {
                                    e = a[c];
                                    if (!(d && e.disabled)) {
                                        if (e instanceof Ext.form.Checkbox) {
                                            b[c] = (e.isChecked()) ? e
                                                    .getValue() : null
                                        } else {
                                            b[c] = e.getValue()
                                        }
                                    }
                                }
                            }
                        }
                        return b
                    },
                    reset : function() {
                        this.getFieldsAsArray().forEach(function(a) {
                            a.reset()
                        });
                        return this
                    },
                    enable : function() {
                        this.getFieldsAsArray().forEach(function(a) {
                            a.enable()
                        });
                        return this
                    },
                    disable : function() {
                        this.getFieldsAsArray().forEach(function(a) {
                            a.disable()
                        });
                        return this
                    },
                    getFieldsAsArray : function() {
                        var a = [];
                        var b = function(c) {
                            if (c.isField) {
                                a.push(c)
                            }
                            if (c.isContainer) {
                                c.items.each(b)
                            }
                        };
                        this.items.each(b);
                        return a
                    },
                    getFields : function(b) {
                        var a = {}, d;
                        var c = function(e) {
                            if (e.isField) {
                                d = e.getName();
                                if ((b && d == b) || typeof b == "undefined") {
                                    if (a.hasOwnProperty(d)) {
                                        if (!Ext.isArray(a[d])) {
                                            a[d] = [ a[d] ]
                                        }
                                        a[d].push(e)
                                    } else {
                                        a[d] = e
                                    }
                                }
                            }
                            if (e.isContainer) {
                                e.items.each(c)
                            }
                        };
                        this.items.each(c);
                        return (b) ? (a[b] || []) : a
                    },
                    getFieldsFromItem : function() {
                    },
                    showMask : function(a, b) {
                        a = Ext.isString(a) ? {
                            message : a
                        } : a;
                        if (a && this.waitTpl) {
                            this.maskTarget = b = Ext.get(b || a.target)
                                    || this.el;
                            b && b.mask(this.waitTpl.apply(a))
                        }
                        return this
                    },
                    hideMask : function() {
                        if (this.maskTarget) {
                            this.maskTarget.unmask();
                            delete this.maskTarget
                        }
                        return this
                    }
                });
Ext.form.FormPanel.prototype.load = Ext.form.FormPanel.prototype.loadModel;
Ext.reg("formpanel", Ext.form.FormPanel);
Ext.reg("form", Ext.form.FormPanel);
Ext.form.FieldSet = Ext.extend(Ext.Panel, {
    componentCls : "x-form-fieldset",
    initComponent : function() {
        this.componentLayout = this.getLayout();
        Ext.form.FieldSet.superclass.initComponent.call(this)
    },
    afterLayout : function(a) {
        Ext.form.FieldSet.superclass.afterLayout.call(this, a);
        if (this.title && !this.titleEl) {
            this.setTitle(this.title)
        } else {
            if (this.titleEl) {
                this.el.insertFirst(this.titleEl)
            }
        }
        if (this.instructions && !this.instructionsEl) {
            this.setInstructions(this.instructions)
        } else {
            if (this.instructionsEl) {
                this.el.appendChild(this.instructionsEl)
            }
        }
    },
    setTitle : function(a) {
        if (this.rendered) {
            if (!this.titleEl) {
                this.titleEl = this.el.insertFirst({
                    cls : this.componentCls + "-title"
                })
            }
            this.titleEl.setHTML(a)
        } else {
            this.title = a
        }
        return this
    },
    setInstructions : function(a) {
        if (this.rendered) {
            if (!this.instructionsEl) {
                this.instructionsEl = this.el.createChild({
                    cls : this.componentCls + "-instructions"
                })
            }
            this.instructionsEl.setHTML(a)
        } else {
            this.instructions = a
        }
        return this
    }
});
Ext.reg("fieldset", Ext.form.FieldSet);
Ext.form.Field = Ext
        .extend(
                Ext.Component,
                {
                    isField : true,
                    fieldCls : "x-form-field",
                    baseCls : "x-field",
                    inputCls : undefined,
                    disabled : false,
                    renderTpl : [
                            '<tpl if="label">',
                            '<div class="x-form-label"><span>{label}</span></div>',
                            "</tpl>",
                            '<tpl if="fieldEl">',
                            '<div class="x-form-field-container"><input id="{inputId}" type="{inputType}" name="{name}" class="{fieldCls}"',
                            '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>',
                            '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>',
                            '<tpl if="style">style="{style}" </tpl>',
                            '<tpl if="maxlength">maxlength="{maxlength}" </tpl>',
                            '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>',
                            '<tpl if="autoCapitalize">autocapitalize="{autoCapitalize}" </tpl>',
                            '<tpl if="autoCorrect">autocorrect="{autoCorrect}" </tpl> />',
                            '<tpl if="useMask"><div class="x-field-mask"></div></tpl>',
                            "</div>",
                            '<tpl if="useClearIcon"><div class="x-field-clear-container"><div class="x-field-clear x-hidden-visibility">&#215;</div></div></tpl>',
                            "</tpl>" ],
                    isFormField : true,
                    autoCreateField : true,
                    inputType : "text",
                    label : null,
                    labelWidth : "30%",
                    labelAlign : "left",
                    required : false,
                    useMask : false,
                    initComponent : function() {
                        Ext.form.Field.superclass.initComponent.call(this)
                    },
                    getName : function() {
                        return this.name || this.id || ""
                    },
                    applyRenderSelectors : function() {
                        this.renderSelectors = Ext.applyIf(this.renderSelectors
                                || {}, {
                            mask : ".x-field-mask",
                            labelEl : ".x-form-label",
                            fieldEl : "."
                                    + Ext.util.Format.trim(
                                            this.renderData.fieldCls).replace(
                                            / /g, ".")
                        });
                        Ext.form.Field.superclass.applyRenderSelectors
                                .call(this)
                    },
                    initRenderData : function() {
                        Ext.form.Field.superclass.initRenderData.apply(this,
                                arguments);
                        Ext.applyIf(this.renderData,
                                {
                                    disabled : this.disabled,
                                    fieldCls : "x-input-"
                                            + this.inputType
                                            + (this.inputCls ? " "
                                                    + this.inputCls : ""),
                                    fieldEl : !this.fieldEl
                                            && this.autoCreateField,
                                    inputId : Ext.id(),
                                    label : this.label,
                                    labelAlign : "x-label-align-"
                                            + this.labelAlign,
                                    name : this.getName(),
                                    required : this.required,
                                    style : this.style,
                                    tabIndex : this.tabIndex,
                                    inputType : this.inputType,
                                    useMask : this.useMask
                                });
                        return this.renderData
                    },
                    initEvents : function() {
                        Ext.form.Field.superclass.initEvents.apply(this,
                                arguments);
                        if (this.fieldEl) {
                            if (this.useMask && this.mask) {
                                this.mon(this.mask, {
                                    click : this.onMaskTap,
                                    scope : this
                                })
                            }
                        }
                    },
                    onRender : function() {
                        Ext.form.Field.superclass.onRender.apply(this,
                                arguments);
                        var a = [];
                        if (this.required) {
                            a.push("x-field-required")
                        }
                        if (this.label) {
                            a.push("x-label-align-" + this.labelAlign)
                        }
                        this.el.addCls(a)
                    },
                    afterRender : function() {
                        Ext.form.Field.superclass.afterRender.apply(this,
                                arguments);
                        if (this.label) {
                            this.setLabelWidth(this.labelWidth)
                        }
                        this.initValue()
                    },
                    isDisabled : function() {
                        return this.disabled
                    },
                    onEnable : function() {
                        this.fieldEl.dom.disabled = false
                    },
                    onDisable : function() {
                        this.fieldEl.dom.disabled = true
                    },
                    initValue : function() {
                        this.setValue(this.value || "", true);
                        this.originalValue = this.getValue()
                    },
                    isDirty : function() {
                        if (this.disabled || !this.rendered) {
                            return false
                        }
                        return String(this.getValue()) !== String(this.originalValue)
                    },
                    onMaskTap : function(a) {
                        if (this.disabled) {
                            return false
                        }
                        return true
                    },
                    showMask : function(a) {
                        if (this.mask) {
                            this.mask.setStyle("display", "block")
                        }
                    },
                    hideMask : function(a) {
                        if (this.mask) {
                            this.mask.setStyle("display", "none")
                        }
                    },
                    reset : function() {
                        this.setValue(this.originalValue)
                    },
                    getValue : function() {
                        if (!this.rendered || !this.fieldEl) {
                            return this.value
                        }
                        return this.fieldEl.getValue()
                    },
                    setValue : function(a) {
                        this.value = a;
                        if (this.rendered && this.fieldEl) {
                            this.fieldEl.dom.value = (Ext.isEmpty(a) ? "" : a)
                        }
                        return this
                    },
                    setLabelWidth : function(a) {
                        if (this.labelEl) {
                            this.labelEl.setWidth(a)
                        }
                        return this
                    }
                });
Ext.reg("field", Ext.form.Field);
Ext.form.Slider = Ext.extend(Ext.form.Field, {
    ui : "slider",
    inputCls : "x-slider",
    inputType : "slider",
    minValue : 0,
    maxValue : 100,
    animationDuration : 200,
    value : 0,
    trackWidth : null,
    monitorOrientation : true,
    renderTpl : [ '<tpl if="label">',
            '<div class="x-form-label"><span>{label}</span></div>', "</tpl>",
            '<tpl if="fieldEl">',
            '<div id="{inputId}" name="{name}" class="{fieldCls}"',
            '<tpl if="tabIndex">tabIndex="{tabIndex}"</tpl>',
            '<tpl if="style">style="{style}" </tpl>', "/></tpl>" ],
    increment : 1,
    constructor : function(a) {
        this.addEvents("beforechange", "change", "drag", "dragend");
        Ext.form.Slider.superclass.constructor.call(this, a)
    },
    initComponent : function() {
        this.tabIndex = -1;
        if (this.increment == 0) {
            this.increment = 1
        }
        this.increment = Math.abs(this.increment);
        this.values = [ this.value ];
        Ext.form.Slider.superclass.initComponent.apply(this, arguments);
        if (this.thumbs == undefined) {
            var a = [], b = this.values, d = b.length, c, e = this
                    .getThumbClass();
            for (c = 0; c < d; c++) {
                a[a.length] = new e({
                    value : b[c],
                    slider : this,
                    listeners : {
                        scope : this,
                        drag : this.onDrag,
                        dragend : this.onThumbDragEnd
                    }
                })
            }
            this.thumbs = a
        }
    },
    initValue : function() {
        var a = this.getThumb();
        if (a.dragObj) {
            a.dragObj.updateBoundary()
        }
        Ext.form.Slider.superclass.initValue.apply(this, arguments)
    },
    onOrientationChange : function() {
        Ext.form.Slider.superclass.onOrientationChange.apply(this, arguments);
        var b = this, a = this.getThumb();
        if (a.dragObj) {
            setTimeout(function() {
                a.dragObj.updateBoundary();
                b.moveThumb(a, b.getPixelValue(a.getValue(), a), 0)
            }, 100)
        }
    },
    getThumbClass : function() {
        return Ext.form.Slider.Thumb
    },
    setValue : function(e, d, c) {
        if (typeof c == "undefined") {
            c = true
        }
        c = !!c;
        var a = this.getThumb(), b = a.getValue(), f = this.constrain(e);
        if (this.fireEvent("beforechange", this, a, f, b) !== false) {
            if (c) {
                this.moveThumb(a, this.getPixelValue(f, a), d)
            }
            a.setValue(f);
            this.doComponentLayout();
            this.fireEvent("change", this, a, f, b)
        }
        return this
    },
    constrain : function(b) {
        var a = b % this.increment;
        b -= a;
        if (Math.abs(a) >= (this.increment / 2)) {
            b += (a > 0) ? this.increment : -this.increment
        }
        b = Math.max(this.minValue, b);
        b = Math.min(this.maxValue, b);
        return b
    },
    getValue : function() {
        return this.getThumb().getValue()
    },
    getThumb : function() {
        return this.thumbs[0]
    },
    getSliderValue : function(b, d) {
        var a = d.dragObj.offsetBoundary.right, c = this.maxValue
                - this.minValue, e;
        this.trackWidth = (a > 0) ? a : this.trackWidth;
        e = c / this.trackWidth;
        return this.minValue + (e * (b))
    },
    getPixelValue : function(e, c) {
        var a = c.dragObj.offsetBoundary.right, b = this.maxValue
                - this.minValue, d;
        this.trackWidth = (a > 0) ? a : this.trackWidth;
        d = this.trackWidth / b;
        return (d * (e - this.minValue))
    },
    renderThumbs : function() {
        var a = this.thumbs, c = a.length, b;
        for (b = 0; b < c; b++) {
            a[b].render(this.fieldEl)
        }
    },
    onThumbDragEnd : function(a) {
        var b = this.getThumbValue(a);
        this.setValue(b);
        this.fireEvent("dragend", this, a.thumb, this.constrain(b))
    },
    getThumbValue : function(a) {
        var b = a.thumb;
        return this.getSliderValue(-a.getOffset().x, b)
    },
    onDrag : function(a) {
        var b = this.getThumbValue(a);
        this.fireEvent("drag", this, a.thumb, this.constrain(b))
    },
    onTap : function(f) {
        if (!this.disabled) {
            var c = this.fieldEl.getPageBox(), d = f.pageX - c.left, b = this
                    .getNearest(d), a = b.dragObj.size.width / 2;
            this.setValue(this.getSliderValue(d - a, b),
                    this.animationDuration, true)
        }
    },
    moveThumb : function(a, b, c) {
        a.dragObj.setOffset(new Ext.util.Offset(b, 0), c)
    },
    afterRender : function(a) {
        var b = this;
        b.renderThumbs();
        Ext.form.Slider.superclass.afterRender.apply(b, arguments);
        b.fieldEl.on({
            scope : b,
            tap : b.onTap
        })
    },
    getNearest : function(a) {
        return this.thumbs[0]
    },
    setThumbsDisabled : function(b) {
        var a = this.thumbs, d = a.length, c = 0;
        for (; c < d; c++) {
            a[c].dragObj[b ? "disable" : "enable"]()
        }
    },
    disable : function() {
        Ext.form.Slider.superclass.disable.call(this);
        this.setThumbsDisabled(true)
    },
    enable : function() {
        Ext.form.Slider.superclass.enable.call(this);
        this.setThumbsDisabled(false)
    }
});
Ext.reg("sliderfield", Ext.form.Slider);
Ext.form.Slider.Thumb = Ext.extend(Ext.form.Field, {
    isField : false,
    baseCls : "x-thumb",
    autoCreateField : false,
    draggable : true,
    value : 0,
    onRender : function() {
        this.draggable = {
            direction : "horizontal",
            constrain : this.slider.fieldEl,
            revert : false,
            thumb : this
        };
        Ext.form.Slider.Thumb.superclass.onRender.apply(this, arguments)
    },
    setValue : function(a) {
        this.value = a;
        return this
    },
    getValue : function() {
        return this.value
    }
});
Ext.reg("sliderthumb", Ext.form.Slider.Thumb);
Ext.form.Toggle = Ext.extend(Ext.form.Slider, {
    minValue : 0,
    maxValue : 1,
    ui : "toggle",
    inputType : "toggle",
    minValueCls : "x-toggle-off",
    maxValueCls : "x-toggle-on",
    animationDuration : 70,
    toggle : function() {
        var a = this.thumbs[0], b = a.getValue();
        this.setValue(b == this.minValue ? this.maxValue : this.minValue,
                this.animationDuration)
    },
    setValue : function(a) {
        Ext.form.Toggle.superclass.setValue.call(this, a,
                this.animationDuration);
        var b = this.fieldEl;
        if (this.constrain(a) === this.minValue) {
            b.addCls(this.minValueCls);
            b.removeCls(this.maxValueCls)
        } else {
            b.addCls(this.maxValueCls);
            b.removeCls(this.minValueCls)
        }
    },
    onTap : function() {
        if (!this.disabled) {
            this.toggle()
        }
    },
    getThumbClass : function() {
        return Ext.form.Toggle.Thumb
    }
});
Ext.reg("togglefield", Ext.form.Toggle);
Ext.form.Toggle.Thumb = Ext.extend(Ext.form.Slider.Thumb, {
    onRender : function() {
        Ext.form.Toggle.Thumb.superclass.onRender.apply(this, arguments);
        Ext.DomHelper.append(this.el, [ {
            cls : "x-toggle-thumb-off",
            html : "<span>OFF</span>"
        }, {
            cls : "x-toggle-thumb-on",
            html : "<span>ON</span>"
        }, {
            cls : "x-toggle-thumb-thumb"
        } ])
    }
});
Ext.form.Text = Ext
        .extend(
                Ext.form.Field,
                {
                    ui : "text",
                    focusCls : "x-field-focus",
                    maxLength : 0,
                    placeHolder : undefined,
                    autoComplete : undefined,
                    autoCapitalize : undefined,
                    autoCorrect : undefined,
                    isFocused : false,
                    isClearIconVisible : false,
                    useMask : Ext.is.iOS,
                    initComponent : function() {
                        this.addEvents("focus", "blur", "keyup", "change",
                                "action");
                        this.enableBubble("action");
                        Ext.form.Text.superclass.initComponent.apply(this,
                                arguments)
                    },
                    applyRenderSelectors : function() {
                        this.renderSelectors = Ext.applyIf(this.renderSelectors
                                || {}, {
                            clearIconEl : ".x-field-clear",
                            clearIconContainerEl : ".x-field-clear-container"
                        });
                        Ext.form.Text.superclass.applyRenderSelectors
                                .call(this)
                    },
                    initRenderData : function() {
                        var e = Ext.form.Text.superclass.initRenderData
                                .call(this), d = this.autoComplete, c = this.autoCapitalize, b = this.autoCorrect;
                        Ext.applyIf(e, {
                            placeHolder : this.placeHolder,
                            maxlength : this.maxLength,
                            useClearIcon : this.useClearIcon
                        });
                        var a = [ true, "on" ];
                        if (d !== undefined) {
                            e.autoComplete = (a.indexOf(d) !== -1) ? "on"
                                    : "off"
                        }
                        if (c !== undefined) {
                            e.autoCapitalize = (a.indexOf(c) !== -1) ? "on"
                                    : "off"
                        }
                        if (b !== undefined) {
                            e.autoCorrect = (a.indexOf(b) !== -1) ? "on"
                                    : "off"
                        }
                        this.renderData = e;
                        return e
                    },
                    initEvents : function() {
                        Ext.form.Text.superclass.initEvents.call(this);
                        if (this.fieldEl) {
                            this.mon(this.fieldEl, {
                                focus : this.onFocus,
                                blur : this.onBlur,
                                keyup : this.onKeyUp,
                                paste : this.updateClearIconVisibility,
                                mousedown : this.onBeforeFocus,
                                scope : this
                            });
                            if (this.clearIconEl) {
                                this.mon(this.clearIconContainerEl, {
                                    scope : this,
                                    tap : this.onClearIconTap
                                })
                            }
                        }
                    },
                    onEnable : function() {
                        Ext.form.Text.superclass.onEnable
                                .apply(this, arguments);
                        this.disabled = false;
                        this.updateClearIconVisibility()
                    },
                    onDisable : function() {
                        Ext.form.Text.superclass.onDisable.apply(this,
                                arguments);
                        this.blur();
                        this.hideClearIcon()
                    },
                    onClearIconTap : function() {
                        if (!this.disabled) {
                            this.setValue("")
                        }
                    },
                    updateClearIconVisibility : function() {
                        var a = this.getValue();
                        if (!a) {
                            a = ""
                        }
                        if (a.length < 1) {
                            this.hideClearIcon()
                        } else {
                            this.showClearIcon()
                        }
                        return this
                    },
                    showClearIcon : function() {
                        if (!this.disabled && this.fieldEl && this.clearIconEl
                                && !this.isClearIconVisible) {
                            this.isClearIconVisible = true;
                            this.fieldEl.addCls("x-field-clearable");
                            this.clearIconEl.removeCls("x-hidden-visibility")
                        }
                        return this
                    },
                    hideClearIcon : function() {
                        if (this.fieldEl && this.clearIconEl
                                && this.isClearIconVisible) {
                            this.isClearIconVisible = false;
                            this.fieldEl.removeCls("x-field-clearable");
                            this.clearIconEl.addCls("x-hidden-visibility")
                        }
                        return this
                    },
                    afterRender : function() {
                        Ext.form.Text.superclass.afterRender.call(this);
                        this.updateClearIconVisibility()
                    },
                    onBeforeFocus : function(a) {
                        this.fireEvent("beforefocus", a)
                    },
                    beforeFocus : Ext.emptyFn,
                    onMaskTap : function(a) {
                        if (Ext.form.Text.superclass.onMaskTap.apply(this,
                                arguments) !== true) {
                            return false
                        }
                        this.maskCorrectionTimer = Ext.defer(this.showMask,
                                1000, this);
                        this.hideMask()
                    },
                    onFocus : function(a) {
                        if (this.mask) {
                            if (this.maskCorrectionTimer) {
                                clearTimeout(this.maskCorrectionTimer)
                            }
                            this.hideMask()
                        }
                        this.beforeFocus();
                        if (this.focusCls) {
                            this.el.addCls(this.focusCls)
                        }
                        if (!this.isFocused) {
                            this.isFocused = true;
                            this.startValue = this.getValue();
                            this.fireEvent("focus", this, a)
                        }
                        Ext.currentlyFocusedField = this
                    },
                    beforeBlur : Ext.emptyFn,
                    onBlur : function(b) {
                        this.beforeBlur();
                        if (this.focusCls) {
                            this.el.removeCls(this.focusCls)
                        }
                        this.isFocused = false;
                        var a = this.getValue();
                        if (String(a) != String(this.startValue)) {
                            this.fireEvent("change", this, a, this.startValue)
                        }
                        this.fireEvent("blur", this, b);
                        this.updateClearIconVisibility();
                        this.showMask();
                        this.afterBlur();
                        Ext.currentlyFocusedField = null
                    },
                    afterBlur : Ext.emptyFn,
                    focus : function() {
                        if (this.rendered && this.fieldEl
                                && this.fieldEl.dom.focus) {
                            this.fieldEl.dom.focus()
                        }
                        return this
                    },
                    blur : function() {
                        if (this.rendered && this.fieldEl
                                && this.fieldEl.dom.blur) {
                            this.fieldEl.dom.blur()
                        }
                        return this
                    },
                    setValue : function() {
                        Ext.form.Text.superclass.setValue
                                .apply(this, arguments);
                        this.updateClearIconVisibility()
                    },
                    onKeyUp : function(a) {
                        this.updateClearIconVisibility();
                        this.fireEvent("keyup", this, a);
                        if (a.browserEvent.keyCode === 13) {
                            this.blur();
                            this.fireEvent("action", this, a)
                        }
                    }
                });
Ext.reg("textfield", Ext.form.Text);
Ext.form.TextField = Ext
        .extend(
                Ext.form.Text,
                {
                    constructor : function() {
                        console
                                .warn("Ext.form.TextField has been deprecated and will be removed in Sencha Touch 1.0. Please use Ext.form.Text instead");
                        Ext.form.TextField.superclass.constructor.apply(this,
                                arguments)
                    }
                });
Ext.form.Password = Ext.extend(Ext.form.Text, {
    inputType : "password",
    autoCapitalize : false
});
Ext.reg("passwordfield", Ext.form.Password);
Ext.form.Email = Ext.extend(Ext.form.Text, {
    inputType : "email",
    autoCapitalize : false
});
Ext.reg("emailfield", Ext.form.Email);
Ext.form.Url = Ext.extend(Ext.form.Text, {
    inputType : "url",
    autoCapitalize : false
});
Ext.reg("urlfield", Ext.form.Url);
Ext.form.Search = Ext.extend(Ext.form.Text, {
    inputType : "search"
});
Ext.reg("searchfield", Ext.form.Search);
Ext.form.Number = Ext
        .extend(
                Ext.form.Text,
                {
                    ui : "number",
                    inputType : "number",
                    minValue : undefined,
                    maxValue : undefined,
                    stepValue : undefined,
                    renderTpl : [
                            '<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>',
                            '<tpl if="fieldEl"><div class="x-form-field-container">',
                            '<input id="{inputId}" type="{inputType}" name="{name}" class="{fieldCls}"',
                            '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>',
                            '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>',
                            '<tpl if="style">style="{style}" </tpl>',
                            '<tpl if="minValue != undefined">min="{minValue}" </tpl>',
                            '<tpl if="maxValue != undefined">max="{maxValue}" </tpl>',
                            '<tpl if="stepValue != undefined">step="{stepValue}" </tpl>',
                            '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>',
                            '<tpl if="autoCapitalize">autocapitalize="{autoCapitalize}" </tpl>',
                            '<tpl if="autoFocus">autofocus="{autoFocus}" </tpl>',
                            "/>",
                            '<tpl if="useMask"><div class="x-field-mask"></div></tpl>',
                            "</div></tpl>",
                            '<tpl if="useClearIcon"><div class="x-field-clear-container"><div class="x-field-clear x-hidden-visibility">&#215;</div><div></tpl>' ],
                    onRender : function() {
                        Ext.apply(this.renderData, {
                            maxValue : this.maxValue,
                            minValue : this.minValue,
                            stepValue : this.stepValue
                        });
                        Ext.form.Number.superclass.onRender.apply(this,
                                arguments)
                    }
                });
Ext.reg("numberfield", Ext.form.Number);
Ext.form.Spinner = Ext
        .extend(
                Ext.form.Number,
                {
                    componentCls : "x-spinner",
                    minValue : Number.NEGATIVE_INFINITY,
                    maxValue : Number.MAX_VALUE,
                    incrementValue : 1,
                    accelerateOnTapHold : true,
                    defaultValue : 0,
                    cycle : false,
                    disableInput : false,
                    useClearIcon : false,
                    autoCapitalize : false,
                    renderTpl : [
                            '<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>',
                            '<tpl if="fieldEl">',
                            '<div class="{componentCls}-body">',
                            '<div class="{componentCls}-down"><span>-</span></div>',
                            '<div class="x-form-field-container">',
                            '<input id="{inputId}" type="{type}" name="{name}" class="{fieldCls}"',
                            '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>',
                            '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>',
                            '<tpl if="style">style="{style}" </tpl>',
                            '<tpl if="minValue != undefined">min="{minValue}" </tpl>',
                            '<tpl if="maxValue != undefined">max="{maxValue}" </tpl>',
                            '<tpl if="stepValue != undefined">step="{stepValue}" </tpl>',
                            '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>',
                            '<tpl if="autoFocus">autofocus="{autoFocus}" </tpl>',
                            "/>",
                            '<tpl if="useMask"><div class="x-field-mask"></div></tpl>',
                            "</div>",
                            '<div class="{componentCls}-up"><span>+</span></div>',
                            "</div>", "</tpl>" ],
                    initComponent : function() {
                        this.addEvents("spin", "spindown", "spinup");
                        Ext.form.Spinner.superclass.initComponent.call(this)
                    },
                    onRender : function() {
                        this.renderData.disableInput = this.disableInput;
                        Ext.applyIf(this.renderSelectors, {
                            spinUpEl : ".x-spinner-up",
                            spinDownEl : ".x-spinner-down"
                        });
                        Ext.form.Spinner.superclass.onRender.apply(this,
                                arguments);
                        this.downRepeater = this.createRepeater(
                                this.spinDownEl, this.onSpinDown);
                        this.upRepeater = this.createRepeater(this.spinUpEl,
                                this.onSpinUp)
                    },
                    initValue : function() {
                        if (isNaN(this.defaultValue)) {
                            this.defaultValue = 0
                        }
                        if (!this.value) {
                            this.value = this.defaultValue
                        }
                        Ext.form.Spinner.superclass.initValue.apply(this,
                                arguments)
                    },
                    createRepeater : function(b, a) {
                        var c = new Ext.util.TapRepeater(b, {
                            accelerate : this.accelerateOnTapHold
                        });
                        this.mon(c, {
                            tap : a,
                            touchstart : this.onTouchStart,
                            touchend : this.onTouchEnd,
                            preventDefault : true,
                            scope : this
                        });
                        return c
                    },
                    onSpinDown : function() {
                        if (!this.disabled) {
                            this.spin(true)
                        }
                    },
                    onSpinUp : function() {
                        if (!this.disabled) {
                            this.spin(false)
                        }
                    },
                    onKeyUp : function(a) {
                        Ext.form.Spinner.superclass.onKeyUp.apply(this,
                                arguments)
                    },
                    onTouchStart : function(a) {
                        if (!this.disabled) {
                            a.el.addCls("x-button-pressed")
                        }
                    },
                    onTouchEnd : function(a) {
                        a.el.removeCls("x-button-pressed")
                    },
                    setValue : function(a) {
                        a = parseFloat(a);
                        if (isNaN(a)) {
                            a = this.defaultValue
                        }
                        Ext.form.Spinner.superclass.setValue.call(this, a)
                    },
                    spin : function(g) {
                        var e = parseFloat(this.getValue()), b = this.incrementValue, d = this.cycle, c = this.minValue, a = this.maxValue, f = g ? "down"
                                : "up";
                        if (g) {
                            e -= b
                        } else {
                            e += b
                        }
                        e = (isNaN(e)) ? this.defaultValue : e;
                        if (e < c) {
                            e = d ? a : c
                        } else {
                            if (e > a) {
                                e = d ? c : a
                            }
                        }
                        this.setValue(e);
                        this.fireEvent("spin" + f, this, e);
                        this.fireEvent("spin", this, e, f)
                    },
                    destroy : function() {
                        Ext.destroy(this.downRepeater, this.upRepeater);
                        Ext.form.Spinner.superclass.destroy.call(this,
                                arguments)
                    }
                });
Ext.reg("spinnerfield", Ext.form.Spinner);
Ext.form.Hidden = Ext.extend(Ext.form.Field, {
    ui : "hidden",
    inputType : "hidden",
    tabIndex : -1
});
Ext.reg("hiddenfield", Ext.form.Hidden);
Ext.form.HiddenField = Ext
        .extend(
                Ext.form.Hidden,
                {
                    constructor : function() {
                        console
                                .warn("Ext.form.HiddenField has been deprecated and will be removed in Sencha Touch 1.0. Please use Ext.form.Hidden instead");
                        Ext.form.HiddenField.superclass.constructor.apply(this,
                                arguments)
                    }
                });
Ext.form.Checkbox = Ext
        .extend(
                Ext.form.Field,
                {
                    ui : "checkbox",
                    inputType : "checkbox",
                    checked : false,
                    value : "",
                    constructor : function(a) {
                        this.addEvents("check", "uncheck");
                        Ext.form.Checkbox.superclass.constructor.call(this, a)
                    },
                    renderTpl : [
                            '<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>',
                            '<tpl if="fieldEl"><input id="{inputId}" type="{inputType}" name="{name}" class="{fieldCls}" tabIndex="-1" ',
                            '<tpl if="checked"> checked </tpl>',
                            '<tpl if="style">style="{style}" </tpl> value="{inputValue}" />',
                            "</tpl>" ],
                    onRender : function() {
                        var a = this.getBooleanIsChecked(this.checked);
                        Ext.apply(this.renderData, {
                            inputValue : String(this.value),
                            checked : a
                        });
                        Ext.form.Checkbox.superclass.onRender.apply(this,
                                arguments);
                        if (this.fieldEl) {
                            this.mon(this.fieldEl, {
                                click : this.onChange,
                                scope : this
                            });
                            this.setChecked(a);
                            this.originalState = this.isChecked()
                        }
                    },
                    onChange : function(a) {
                        if (a) {
                            if (a.browserEvent) {
                                a = a.browserEvent
                            }
                            if (Ext.supports.Touch && !a.isSimulated) {
                                a.preventDefault();
                                a.stopPropagation();
                                return
                            }
                        }
                        if (this.isChecked()) {
                            this.fireEvent("check", this)
                        } else {
                            this.fireEvent("uncheck", this)
                        }
                    },
                    isChecked : function() {
                        if (this.rendered) {
                            return this.fieldEl.dom.checked || false
                        } else {
                            return !!this.checked
                        }
                    },
                    setChecked : function(b) {
                        var d = this.getBooleanIsChecked(b), e = this.rendered, a, c;
                        if (e) {
                            c = this.fieldEl.dom;
                            a = c.checked
                        } else {
                            a = !!this.checked
                        }
                        if (a != d) {
                            if (e) {
                                c.checked = d
                            } else {
                                this.checked = d
                            }
                            this.onChange()
                        }
                        return this
                    },
                    check : function() {
                        return this.setChecked(true)
                    },
                    uncheck : function() {
                        return this.setChecked(false)
                    },
                    reset : function() {
                        Ext.form.Checkbox.superclass.reset.apply(this,
                                arguments);
                        this.setChecked(this.originalState);
                        return this
                    },
                    getBooleanIsChecked : function(a) {
                        return /^(true|1|on)/i.test(String(a))
                    },
                    getSameGroupFields : function() {
                        var b = this.el.up("form"), c = Ext.getCmp(b.id), a = [];
                        if (c) {
                            a = c.getFields(this.getName())
                        }
                        return a
                    },
                    getGroupValues : function() {
                        var a = [];
                        this.getSameGroupFields().forEach(function(b) {
                            if (b.isChecked()) {
                                a.push(b.getValue())
                            }
                        });
                        return a
                    },
                    setGroupValues : function(a) {
                        this.getSameGroupFields().forEach(function(b) {
                            b.setChecked((a.indexOf(b.getValue()) !== -1))
                        });
                        return this
                    },
                    setValue : function(a) {
                        a = String(a);
                        Ext.form.Checkbox.superclass.setValue.call(this, a)
                    }
                });
Ext.reg("checkboxfield", Ext.form.Checkbox);
Ext.form.Radio = Ext.extend(Ext.form.Checkbox, {
    inputType : "radio",
    ui : "radio",
    getGroupValue : function() {
        var c, a = this.getSameGroupFields();
        for ( var b = 0; b < a.length; b++) {
            c = a[b];
            if (c.isChecked()) {
                return c.getValue()
            }
        }
        return null
    },
    setGroupValue : function(d) {
        var e, b = this.getSameGroupFields(), c = 0, a = b.length;
        for (; c < a; c++) {
            e = b[c];
            if (e.getValue() == d) {
                e.check();
                return
            }
        }
    }
});
Ext.reg("radiofield", Ext.form.Radio);
Ext.form.Select = Ext.extend(Ext.form.Text, {
    ui : "select",
    valueField : "value",
    displayField : "text",
    tabIndex : -1,
    useMask : true,
    monitorOrientation : true,
    initComponent : function() {
        var a = this.options;
        if (this.store) {
            this.store = Ext.StoreMgr.lookup(this.store)
        } else {
            this.store = new Ext.data.Store({
                fields : [ this.valueField, this.displayField ]
            });
            if (a && Ext.isArray(a) && a.length > 0) {
                this.setOptions(this.options)
            }
        }
        Ext.form.Select.superclass.initComponent.call(this);
        this.addEvents("change")
    },
    onRender : function() {
        Ext.form.Select.superclass.onRender.apply(this, arguments);
        var a = this.hiddenName;
        if (a) {
            this.hiddenField = this.el.insertSibling({
                name : a,
                tag : "input",
                type : "hidden"
            }, "after")
        }
    },
    getPicker : function() {
        if (!this.picker) {
            this.picker = new Ext.Picker({
                slots : [ {
                    align : "center",
                    name : this.name,
                    valueField : this.valueField,
                    displayField : this.displayField,
                    value : this.getValue(),
                    store : this.store
                } ],
                listeners : {
                    change : this.onPickerChange,
                    scope : this
                }
            })
        }
        return this.picker
    },
    getListPanel : function() {
        if (!this.listPanel) {
            this.listPanel = new Ext.Panel({
                floating : true,
                stopMaskTapEvent : false,
                hideOnMaskTap : true,
                cls : "x-select-overlay",
                scroll : "vertical",
                items : {
                    xtype : "list",
                    store : this.store,
                    itemId : "list",
                    scroll : false,
                    itemTpl : [
                            '<span class="x-list-label">{' + this.displayField
                                    + "}</span>",
                            '<span class="x-list-selected"></span>' ],
                    listeners : {
                        select : this.onListSelect,
                        scope : this
                    }
                }
            })
        }
        return this.listPanel
    },
    onOrientationChange : function() {
        if (this.listPanel && !this.listPanel.hidden && !Ext.is.Phone) {
            this.listPanel.showBy(this.el, false, false)
        }
    },
    onMaskTap : function() {
        if (this.disabled) {
            return
        }
        this.showComponent()
    },
    showComponent : function() {
        if (Ext.is.Phone) {
            var c = this.getPicker(), b = this.name, e = {};
            e[b] = this.getValue();
            c.show();
            c.setValue(e)
        } else {
            var d = this.getListPanel(), a = this.store.findExact(
                    this.valueField, this.value);
            d.showBy(this.el, "fade", false);
            d.down("#list").getSelectionModel().select(a != -1 ? a : 0, false,
                    true)
        }
    },
    onListSelect : function(a, b) {
        if (b) {
            this.setValue(b.get(this.valueField));
            this.fireEvent("change", this, this.getValue())
        }
        this.listPanel.hide({
            type : "fade",
            out : true,
            scope : this
        })
    },
    onPickerChange : function(a, c) {
        var b = this.getValue(), d = c[this.name];
        if (d != b) {
            this.setValue(d);
            this.fireEvent("change", this, d)
        }
    },
    setValue : function(d) {
        var b = 0, a = this.hiddenField, c;
        if (d) {
            b = this.store.findExact(this.valueField, d)
        }
        c = this.store.getAt(b);
        if (c && this.rendered) {
            this.fieldEl.dom.value = c.get(this.displayField);
            this.value = c.get(this.valueField);
            if (a) {
                a.dom.value = this.value
            }
        } else {
            if (this.rendered) {
                this.fieldEl.dom.value = d
            }
            this.value = d
        }
        if (this.picker) {
            var e = {};
            e[this.name] = this.value;
            this.picker.setValue(e)
        }
        return this
    },
    getValue : function() {
        return this.value
    },
    setOptions : function(b, a) {
        if (!b) {
            this.store.clearData();
            this.setValue(null)
        } else {
            this.store.loadData(b, a)
        }
    },
    destroy : function() {
        Ext.form.Select.superclass.destroy.apply(this, arguments);
        Ext.destroy(this.listPanel, this.picker, this.hiddenField)
    }
});
Ext.reg("selectfield", Ext.form.Select);
Ext.form.TextArea = Ext
        .extend(
                Ext.form.Text,
                {
                    ui : "textarea",
                    maxRows : undefined,
                    autoCapitalize : false,
                    renderTpl : [
                            '<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>',
                            '<tpl if="fieldEl"><div class="x-form-field-container">',
                            '<textarea id="{inputId}" type="{type}" name="{name}" class="{fieldCls}"',
                            '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>',
                            '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>',
                            '<tpl if="style">style="{style}" </tpl>',
                            '<tpl if="maxRows != undefined">rows="{maxRows}" </tpl>',
                            '<tpl if="maxlength">maxlength="{maxlength}" </tpl>',
                            '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>',
                            '<tpl if="autoCapitalize">autocapitalize="{autoCapitalize}" </tpl>',
                            '<tpl if="autoFocus">autofocus="{autoFocus}" </tpl>',
                            "></textarea>",
                            '<tpl if="useMask"><div class="x-field-mask"></div></tpl>',
                            "</div></tpl>" ],
                    onRender : function() {
                        this.renderData.maxRows = this.maxRows;
                        Ext.form.TextArea.superclass.onRender.apply(this,
                                arguments)
                    },
                    onKeyUp : function(a) {
                        this.fireEvent("keyup", this, a)
                    }
                });
Ext.reg("textareafield", Ext.form.TextArea);
Ext.form.DatePicker = Ext.extend(Ext.form.Field,
        {
            ui : "select",
            picker : null,
            destroyPickerOnHide : false,
            initComponent : function() {
                this.addEvents("change");
                this.tabIndex = -1;
                this.useMask = true;
                Ext.form.Text.superclass.initComponent.apply(this, arguments)
            },
            getDatePicker : function() {
                if (!this.datePicker) {
                    if (this.picker instanceof Ext.DatePicker) {
                        this.datePicker = this.picker
                    } else {
                        this.datePicker = new Ext.DatePicker(Ext
                                .apply(this.picker || {}))
                    }
                    this.datePicker.setValue(this.value || null);
                    this.datePicker.on({
                        scope : this,
                        change : this.onPickerChange,
                        hide : this.onPickerHide
                    })
                }
                return this.datePicker
            },
            onMaskTap : function() {
                if (Ext.form.DatePicker.superclass.onMaskTap.apply(this,
                        arguments) !== true) {
                    return false
                }
                this.getDatePicker().show()
            },
            onPickerChange : function(a, b) {
                this.setValue(b);
                this.fireEvent("change", this, this.getValue())
            },
            onPickerHide : function() {
                if (this.destroyPickerOnHide && this.datePicker) {
                    this.datePicker.destroy()
                }
            },
            setValue : function(b, a) {
                if (this.datePicker) {
                    this.datePicker.setValue(b, a);
                    this.value = (b != null) ? this.datePicker.getValue()
                            : null
                } else {
                    if (!Ext.isDate(b) && !Ext.isObject(b)) {
                        b = null
                    }
                    if (Ext.isObject(b)) {
                        this.value = new Date(b.year, b.month - 1, b.day)
                    } else {
                        this.value = b
                    }
                }
                if (this.rendered) {
                    this.fieldEl.dom.value = this.getValue(true)
                }
                return this
            },
            getValue : function(b) {
                var a = this.value || null;
                return (b && Ext.isDate(a)) ? a
                        .format(Ext.util.Format.defaultDateFormat) : a
            },
            onDestroy : function() {
                if (this.datePicker) {
                    this.datePicker.destroy()
                }
                Ext.form.DatePicker.superclass.onDestroy.call(this)
            }
        });
Ext.reg("datepickerfield", Ext.form.DatePicker);
Ext.layout.LayoutManager = new Ext.AbstractManager({
    create : function(a, b) {
        if (!a) {
            a = b
        }
        if (Ext.isString(a)) {
            return new this.types[a || b]
        } else {
            if (Ext.isObject(a)) {
                if (a.isLayout) {
                    return a
                } else {
                    return new this.types[a.type || b](a)
                }
            }
        }
    }
});
Ext.regLayout = function() {
    return Ext.layout.LayoutManager.registerType.apply(
            Ext.layout.LayoutManager, arguments)
};
Ext.layout.Layout = Ext.extend(Object, {
    isLayout : true,
    initialized : false,
    constructor : function(a) {
        this.id = Ext.id(null, "ext-layout-" + this.type + "-");
        Ext.apply(this, a)
    },
    layout : function() {
        var a = this;
        a.layoutBusy = true;
        a.initLayout();
        if (a.beforeLayout.apply(a, arguments) !== false) {
            a.onLayout.apply(a, arguments);
            a.afterLayout();
            a.owner.needsLayout = false;
            a.layoutBusy = false
        }
    },
    beforeLayout : function() {
        this.renderItems(this.getLayoutItems(), this.getTarget());
        return true
    },
    renderItems : function(a, e) {
        var d = a.length, b = 0, c;
        for (; b < d; b++) {
            c = a[b];
            if (c && !c.rendered) {
                this.renderItem(c, b, e)
            } else {
                if (!this.isValidParent(c, e)) {
                    this.moveItem(c, b, e)
                }
            }
        }
    },
    renderItem : function(b, a, c) {
        if (!b.rendered) {
            b.render(c, a);
            this.configureItem(b, a);
            this.childrenChanged = true
        }
    },
    moveItem : function(b, a, c) {
        if (typeof a == "number") {
            a = c.dom.childNodes[a]
        }
        c = c.dom || c;
        c.insertBefore(b.el.dom, a || null);
        b.container = c;
        this.configureItem(b, a);
        this.childrenChanged = true
    },
    initLayout : function() {
        if (!this.initialized && !Ext.isEmpty(this.targetCls)) {
            this.getTarget().addCls(this.targetCls)
        }
        this.initialized = true
    },
    setOwner : function(a) {
        this.owner = a
    },
    getLayoutItems : function() {
        return []
    },
    isValidParent : function(a, b) {
        var c = a.el ? a.el.dom : Ext.getDom(a);
        return b && (c.parentNode == (b.dom || b))
    },
    configureItem : function(b, a) {
        if (this.itemCls) {
            b.el.addCls(this.itemCls)
        }
    },
    onLayout : Ext.emptyFn,
    afterLayout : Ext.emptyFn,
    onRemove : Ext.emptyFn,
    onDestroy : Ext.emptyFn,
    afterRemove : function(a) {
        if (this.itemCls && a.rendered) {
            a.el.removeCls(this.itemCls)
        }
    },
    destroy : function() {
        if (!Ext.isEmpty(this.targetCls)) {
            var a = this.getTarget();
            if (a) {
                a.removeCls(this.targetCls)
            }
        }
        this.onDestroy()
    }
});
Ext.layout.ComponentLayout = Ext
        .extend(
                Ext.layout.Layout,
                {
                    type : "component",
                    monitorChildren : true,
                    beforeLayout : function(d, c) {
                        Ext.layout.ComponentLayout.superclass.beforeLayout
                                .call(this);
                        var b = this.owner, a = b.isVisible(), e;
                        if (!a && b.hiddenOwnerCt) {
                            e = b.hiddenOwnerCt.layoutOnShow;
                            e.remove(b);
                            e.add(b);
                            b.needsLayout = {
                                width : d,
                                height : c,
                                isSetSize : false
                            }
                        }
                        return a && this.needsLayout(d, c)
                    },
                    needsLayout : function(c, a) {
                        this.lastComponentSize = this.lastComponentSize || {
                            width : -Infinity,
                            height : -Infinity
                        };
                        var b = this.childrenChanged;
                        this.childrenChanged = false;
                        return (b || this.lastComponentSize.width !== c || this.lastComponentSize.height !== a)
                    },
                    setElementSize : function(c, b, a) {
                        if (b !== undefined && a !== undefined) {
                            c.setSize(b, a)
                        } else {
                            if (a !== undefined) {
                                c.setHeight(a)
                            } else {
                                if (b !== undefined) {
                                    c.setWidth(b)
                                }
                            }
                        }
                    },
                    getTarget : function() {
                        return this.owner.el
                    },
                    setTargetSize : function(b, a) {
                        this.setElementSize(this.owner.el, b, a);
                        this.lastComponentSize = {
                            width : b,
                            height : a
                        }
                    },
                    afterLayout : function() {
                        var b = this.owner, e = b.layout, d = b.ownerCt, h, g, f, c, a;
                        b.afterComponentLayout(this);
                        if (e && e.isLayout) {
                            e.layout()
                        }
                        if (d && d.componentLayout
                                && d.componentLayout.monitorChildren
                                && !d.componentLayout.layoutBusy) {
                            d.componentLayout.childrenChanged = true;
                            if (d.layout && !d.layout.layoutBusy) {
                                if (d.layout.type == "autocontainer") {
                                    d.doComponentLayout(c, a)
                                } else {
                                    d.layout.layout()
                                }
                            }
                        }
                    }
                });
Ext.layout.AutoComponentLayout = Ext.extend(Ext.layout.ComponentLayout, {
    type : "autocomponent",
    onLayout : function(b, a) {
        this.setTargetSize(b, a)
    }
});
Ext.regLayout("autocomponent", Ext.layout.AutoComponentLayout);
Ext.layout.DockLayout = Ext
        .extend(
                Ext.layout.ComponentLayout,
                {
                    type : "dock",
                    itemCls : "x-docked",
                    onLayout : function(a, p) {
                        var m = this, b = m.owner, j = b.body, d = b.ownerCt, i = b.layout, f = b.collapsed, e = b.contracted, k = b.expanded, h = m.headerItem, l = m
                                .getTarget(), n = false, o = false, g;
                        var c = m.info = {
                            boxes : [],
                            size : {
                                width : a,
                                height : p
                            },
                            padding : {
                                top : l.getPadding("t"),
                                right : l.getPadding("r"),
                                bottom : l.getPadding("b"),
                                left : l.getPadding("l")
                            },
                            border : {
                                top : l.getBorderWidth("t"),
                                right : l.getBorderWidth("r"),
                                bottom : l.getBorderWidth("b"),
                                left : l.getBorderWidth("l")
                            },
                            bodyMargin : {
                                top : j.getMargin("t"),
                                right : j.getMargin("r"),
                                bottom : j.getMargin("b"),
                                left : j.getMargin("l")
                            },
                            bodyBox : {}
                        };
                        if (p === undefined || p === null || a === undefined
                                || a === null || e) {
                            if ((p === undefined || p === null)
                                    && (a === undefined || a === null)) {
                                o = true;
                                n = true;
                                if (!b.animCollapse || (!k && !e)) {
                                    m.setTargetSize(null, null)
                                }
                                m.setBodyBox({
                                    width : null,
                                    height : null
                                })
                            } else {
                                if (p === undefined || p === null) {
                                    o = true;
                                    if (!b.animCollapse || (!k && !e)) {
                                        m.setTargetSize(a, null)
                                    }
                                    m.setBodyBox({
                                        width : a,
                                        height : null
                                    })
                                } else {
                                    n = true;
                                    if (!b.animCollapse || (!k && !e)) {
                                        m.setTargetSize(null, p)
                                    }
                                    m.setBodyBox({
                                        width : null,
                                        height : p
                                    })
                                }
                            }
                            if (!f && i && i.isLayout) {
                                i.layout()
                            }
                            m.dockItems(n, o);
                            if (f) {
                                if (h) {
                                    if (h.dock == "top" || h.dock == "bottom") {
                                        c.size.height = h.getHeight()
                                    } else {
                                        c.size.width = h.getWidths()
                                    }
                                } else {
                                    c.size.height = 0
                                }
                            }
                            if (k || e) {
                                if (b.animCollapse) {
                                    Ext.createDelegate(b.animCollapseFn, b,
                                            [ c.size.width, c.size.height ])()
                                } else {
                                    Ext.createDelegate(
                                            b["after"
                                                    + (k ? "Expand"
                                                            : "Collapse")], b)
                                            ();
                                    m
                                            .setTargetSize(c.size.width,
                                                    c.size.height)
                                }
                            } else {
                                m.setTargetSize(c.size.width, c.size.height)
                            }
                        } else {
                            if (k || e) {
                                if (b.animCollapse) {
                                    Ext.createDelegate(b.animCollapseFn, b,
                                            [ a, p ])()
                                } else {
                                    Ext.createDelegate(
                                            b["after"
                                                    + (k ? "Expand"
                                                            : "Collapse")], b)
                                            ();
                                    m.setTargetSize(a, p)
                                }
                            } else {
                                m.setTargetSize(a, p);
                                m.dockItems()
                            }
                        }
                        Ext.layout.DockLayout.superclass.onLayout.call(m, a, p)
                    },
                    afterLayout : function() {
                        Ext.layout.DockLayout.superclass.afterLayout.call(this)
                    },
                    dockItems : function(h, a) {
                        this.calculateDockBoxes(h, a);
                        var f = this.info, g = this.owner.collapsed, c = f.boxes, e = c.length, d, b;
                        for (b = 0; b < e; b++) {
                            d = c[b];
                            if (g === true && !d.isHeader) {
                                continue
                            }
                            d.item.setPosition(d.x, d.y)
                        }
                        if (h) {
                            f.bodyBox.width = null
                        }
                        if (a) {
                            f.bodyBox.height = null
                        }
                        this.setBodyBox(f.bodyBox)
                    },
                    calculateDockBoxes : function(m, p) {
                        var x = this, y = x.getTarget(), l = x.getLayoutItems(), a = x.owner, b = a.contracted, o = a.expanded, f = a.body, t = x.info, k = t.size, c = l.length, g = t.padding, n = t.border, u, q, d, e, s, v, j;
                        if (p) {
                            k.height = f.getHeight() + g.top + n.top + g.bottom
                                    + n.bottom
                        } else {
                            k.height = y.getHeight() - y.getMargin("tb")
                        }
                        if (m) {
                            k.width = f.getWidth() + g.left + n.left + g.right
                                    + n.right
                        } else {
                            k.width = y.getWidth() - y.getMargin("lr")
                        }
                        t.bodyBox = {
                            x : n.left + g.left,
                            y : n.top + g.top,
                            width : k.width - g.left - n.left - g.right
                                    - n.right,
                            height : k.height - n.top - g.top - n.bottom
                                    - g.bottom
                        };
                        for (q = 0; q < c; q++) {
                            u = l[q];
                            if (u.isHeader) {
                                x.headerItem = u
                            }
                            d = x.initBox(u);
                            if (p === true) {
                                d = x.adjustAutoBox(d, q)
                            } else {
                                d = x.adjustSizedBox(d, q)
                            }
                            t.boxes.push(d)
                        }
                    },
                    adjustSizedBox : function(c, b) {
                        var a = this.info.bodyBox;
                        switch (c.type) {
                        case "top":
                            c.y = a.y;
                            break;
                        case "left":
                            c.x = a.x;
                            break;
                        case "bottom":
                            c.y = (a.y + a.height) - c.height;
                            break;
                        case "right":
                            c.x = (a.x + a.width) - c.width;
                            break
                        }
                        if (!c.overlay) {
                            switch (c.type) {
                            case "top":
                                a.y += c.height;
                                a.height -= c.height;
                                break;
                            case "left":
                                a.x += c.width;
                                a.width -= c.width;
                                break;
                            case "bottom":
                                a.height -= c.height;
                                break;
                            case "right":
                                a.width -= c.width;
                                break
                            }
                        }
                        return c
                    },
                    adjustAutoBox : function(c, f) {
                        var a = this.info, g = a.bodyBox, j = a.size, d = a.boxes, h = c.type, b, e;
                        if (h == "top" || h == "bottom") {
                            for (b = 0; b < f; b++) {
                                e = d[b];
                                if (e.stretched && e.type == "left"
                                        || e.type == "right") {
                                    e.height += c.height
                                } else {
                                    if (e.type == "bottom") {
                                        e.y += c.height
                                    }
                                }
                            }
                        }
                        switch (h) {
                        case "top":
                            c.y = g.y;
                            if (!c.overlay) {
                                g.y += c.height
                            }
                            j.height += c.height;
                            break;
                        case "bottom":
                            c.y = (g.y + g.height);
                            j.height += c.height;
                            break;
                        case "left":
                            c.x = g.x;
                            if (!c.overlay) {
                                g.x += c.width;
                                g.width -= c.width
                            }
                            break;
                        case "right":
                            if (!c.overlay) {
                                g.width -= c.width
                            }
                            c.x = (g.x + g.width);
                            break
                        }
                        return c
                    },
                    initBox : function(d) {
                        var b = this.info.bodyBox, a = (d.dock == "top" || d.dock == "bottom"), c = {
                            item : d,
                            overlay : d.overlay,
                            type : d.dock
                        };
                        if (d.stretch !== false) {
                            c.stretched = true;
                            if (a) {
                                c.x = b.x;
                                c.width = b.width;
                                d.doComponentLayout(c.width
                                        - d.el.getMargin("lr"))
                            } else {
                                c.y = b.y;
                                c.height = b.height;
                                d.doComponentLayout(undefined, c.height
                                        - d.el.getMargin("tb"))
                            }
                        } else {
                            d.doComponentLayout();
                            c.width = d.getWidth();
                            c.height = d.getHeight();
                            if (a) {
                                c.x = (d.align == "right") ? b.width - c.width
                                        : b.x
                            }
                        }
                        if (c.width == undefined) {
                            c.width = d.getWidth() + d.el.getMargin("lr")
                        }
                        if (c.height == undefined) {
                            c.height = d.getHeight() + d.el.getMargin("tb")
                        }
                        return c
                    },
                    getLayoutItems : function() {
                        return this.owner.getDockedItems()
                    },
                    setBodyBox : function(f) {
                        var i = this, a = i.owner, g = a.body, e = a.contracted, h = a.expanded, b = i.info, d = b.bodyMargin, j = b.padding, c = b.border;
                        if (Ext.isNumber(f.width)) {
                            f.width -= d.left + d.right
                        }
                        if (Ext.isNumber(f.height)) {
                            f.height -= d.top + d.bottom
                        }
                        i.setElementSize(g, f.width, f.height);
                        g.setLeft(f.x - j.left - c.left);
                        g.setTop(f.y - j.top - c.top)
                    },
                    configureItem : function(b, c) {
                        Ext.layout.DockLayout.superclass.configureItem.call(
                                this, b, c);
                        var a = b.el || Ext.get(b);
                        if (this.itemCls) {
                            a.addCls(this.itemCls + "-" + b.dock)
                        }
                    },
                    afterRemove : function(a) {
                        Ext.layout.DockLayout.superclass.afterRemove.call(this,
                                a);
                        if (this.itemCls) {
                            a.el.removeCls(this.itemCls + "-" + a.dock)
                        }
                        var b = a.el.dom;
                        if (b) {
                            b.parentNode.removeChild(b)
                        }
                        this.childrenChanged = true
                    }
                });
Ext.regLayout("dock", Ext.layout.DockLayout);
Ext.layout.FieldLayout = Ext.extend(Ext.layout.ComponentLayout, {
    type : "field",
    onLayout : function(b, a) {
        Ext.layout.FieldLayout.superclass.onLayout.call(this, owner, target);
        this.setTargetSize(b, a)
    },
    handleLabel : function() {
        this.owner.labelEl.setWidth(this.owner.labelWidth)
    }
});
Ext.regLayout("field", Ext.layout.FieldLayout);
Ext.layout.ContainerLayout = Ext.extend(Ext.layout.Layout, {
    type : "container",
    getLayoutItems : function() {
        return this.owner && this.owner.items && this.owner.items.items || []
    },
    afterLayout : function() {
        this.owner.afterLayout(this)
    },
    getTarget : function() {
        return this.owner.getTargetEl()
    }
});
Ext.layout.AutoContainerLayout = Ext.extend(Ext.layout.ContainerLayout, {
    type : "autocontainer",
    onLayout : function(a, e) {
        var b = this.getLayoutItems(), d = b.length, c;
        for (c = 0; c < d; c++) {
            b[c].doComponentLayout()
        }
    }
});
Ext.regLayout("auto", Ext.layout.AutoContainerLayout);
Ext.regLayout("autocontainer", Ext.layout.AutoContainerLayout);
Ext.layout.FitLayout = Ext.extend(Ext.layout.ContainerLayout, {
    itemCls : "x-fit-item",
    targetCls : "x-layout-fit",
    type : "fit",
    onLayout : function() {
        Ext.layout.FitLayout.superclass.onLayout.call(this);
        if (this.owner.items.length) {
            var b = this.getTargetBox(), a = this.owner.items.get(0);
            this.setItemBox(a, b);
            a.cancelAutoSize = true
        }
    },
    getTargetBox : function() {
        var d = this.getTarget(), b = d.getSize(), c = {
            left : d.getPadding("l"),
            right : d.getPadding("r"),
            top : d.getPadding("t"),
            bottom : d.getPadding("b")
        }, a = {
            left : d.getBorderWidth("l"),
            right : d.getBorderWidth("r"),
            top : d.getBorderWidth("t"),
            bottom : d.getBorderWidth("b")
        };
        return {
            width : b.width - c.left - c.right - a.left - a.right,
            height : b.height - c.top - c.bottom - a.top - a.bottom,
            x : c.left + a.left,
            y : c.top + a.top
        }
    },
    setItemBox : function(b, a) {
        if (b && a.height > 0) {
            a = Ext.apply({}, a);
            a.width -= b.el.getMargin("lr");
            a.height -= b.el.getMargin("tb");
            b.setCalculatedSize(a);
            b.setPosition(a)
        }
    }
});
Ext.regLayout("fit", Ext.layout.FitLayout);
Ext.layout.CardLayout = Ext
        .extend(
                Ext.layout.FitLayout,
                {
                    type : "card",
                    sizeAllCards : false,
                    hideInactive : true,
                    beforeLayout : function() {
                        this.activeItem = this.getActiveItem();
                        return Ext.layout.CardLayout.superclass.beforeLayout
                                .apply(this, arguments)
                    },
                    onLayout : function() {
                        Ext.layout.FitLayout.superclass.onLayout.apply(this,
                                arguments);
                        var f = this.activeItem, b = this.getLayoutItems(), e = b.length, a = this
                                .getTargetBox(), c, d;
                        for (c = 0; c < e; c++) {
                            d = b[c];
                            this.setItemBox(d, a)
                        }
                        if (!this.firstActivated && f) {
                            if (f.fireEvent("beforeactivate", f) !== false) {
                                f.fireEvent("activate", f)
                            }
                            this.firstActivated = true
                        }
                    },
                    getActiveItem : function() {
                        if (!this.activeItem && this.owner) {
                            this.activeItem = this
                                    .parseActiveItem(this.owner.activeItem)
                        }
                        if (this.activeItem
                                && this.owner.items.items
                                        .indexOf(this.activeItem) != -1) {
                            return this.activeItem
                        }
                        return null
                    },
                    parseActiveItem : function(a) {
                        if (a && a.isComponent) {
                            return a
                        } else {
                            if (typeof a == "number" || a == undefined) {
                                return this.getLayoutItems()[a || 0]
                            } else {
                                return this.owner.getComponent(a)
                            }
                        }
                    },
                    configureItem : function(b, a) {
                        Ext.layout.FitLayout.superclass.configureItem.call(
                                this, b, a);
                        if (this.hideInactive && this.activeItem !== b) {
                            b.hide()
                        } else {
                            b.show()
                        }
                    },
                    onRemove : function(a) {
                        if (a === this.activeItem) {
                            this.activeItem = null;
                            if (this.owner.items.getCount() == 0) {
                                this.firstActivated = false
                            }
                        }
                    },
                    getAnimation : function(b, a) {
                        var c = (b || {}).cardSwitchAnimation;
                        if (c === false) {
                            return false
                        }
                        return c || a.cardSwitchAnimation
                    },
                    setActiveItem : function(b, f) {
                        var e = this, a = e.owner, g = Ext.getDoc(), d = e.activeItem, c;
                        f = (f == undefined) ? this.getAnimation(b, a) : f;
                        b = e.parseActiveItem(b);
                        c = a.items.indexOf(b);
                        if (c == -1) {
                            a.add(b)
                        }
                        if (b && d != b
                                && a.onBeforeCardSwitch(b, d, c, !!f) !== false) {
                            if (!b.rendered) {
                                this.layout()
                            }
                            if (b.fireEvent("beforeactivate", b, d) === false) {
                                return false
                            }
                            if (d
                                    && d.fireEvent("beforedeactivate", d, b) === false) {
                                return false
                            }
                            if (b.hidden) {
                                b.show()
                            }
                            e.activeItem = b;
                            if (f) {
                                g.on("click", Ext.emptyFn, e, {
                                    single : true,
                                    preventDefault : true
                                });
                                Ext.Anim.run(b, f, {
                                    out : false,
                                    autoClear : true,
                                    scope : e,
                                    after : function() {
                                        Ext.defer(function() {
                                            g.un("click", Ext.emptyFn, e)
                                        }, 50, e);
                                        b.fireEvent("activate", b, d);
                                        if (!d) {
                                            a.onCardSwitch(b, d, c, true)
                                        }
                                    }
                                });
                                if (d) {
                                    Ext.Anim.run(d, f, {
                                        out : true,
                                        autoClear : true,
                                        after : function() {
                                            d.fireEvent("deactivate", d, b);
                                            if (e.hideInactive
                                                    && e.activeItem != d) {
                                                d.hide()
                                            }
                                            a.onCardSwitch(b, d, c, true)
                                        }
                                    })
                                }
                            } else {
                                b.fireEvent("activate", b, d);
                                if (d) {
                                    d.fireEvent("deactivate", d, b);
                                    if (e.hideInactive) {
                                        d.hide()
                                    }
                                }
                                a.onCardSwitch(b, d, c, false)
                            }
                            return b
                        }
                        return false
                    },
                    getNext : function(c) {
                        var a = this.getLayoutItems(), b = a
                                .indexOf(this.activeItem);
                        return a[b + 1] || (c ? a[0] : false)
                    },
                    next : function(b, a) {
                        return this.setActiveItem(this.getNext(a), b)
                    },
                    getPrev : function(c) {
                        var a = this.getLayoutItems(), b = a
                                .indexOf(this.activeItem);
                        return a[b - 1] || (c ? a[a.length - 1] : false)
                    },
                    prev : function(b, a) {
                        return this.setActiveItem(this.getPrev(a), b)
                    }
                });
Ext.regLayout("card", Ext.layout.CardLayout);
Ext.layout.BoxLayout = Ext.extend(Ext.layout.ContainerLayout, {
    type : "box",
    targetCls : "x-layout-box",
    innerCls : "x-layout-box-inner",
    pack : "start",
    align : "center",
    notifyOwnerCtContainer : true,
    fixedLayout : false,
    direction : "normal",
    onLayout : function() {
        Ext.layout.BoxLayout.superclass.onLayout.call(this);
        if (this.pack === "left" || this.pack === "top") {
            this.pack = "start"
        } else {
            if (this.pack === "right" || this.pack === "bottom") {
                this.pack = "end"
            }
        }
        var d = this.getTarget(), c = d.parent(), b = (c.getWidth()
                - c.getPadding("lr") - c.getBorderWidth("lr"))
                + "px", a = (c.getHeight() - c.getPadding("tb") - c
                .getBorderWidth("tb"))
                + "px";
        d.setStyle({
            "-webkit-box-orient" : this.orientation,
            "-webkit-box-direction" : this.direction,
            "-webkit-box-pack" : this.pack,
            "-webkit-box-align" : this.align
        });
        if (this.orientation == "horizontal") {
            d.setStyle({
                "min-width" : b,
                height : a
            })
        } else {
            d.setStyle({
                "min-height" : a,
                width : b
            })
        }
        this.prepareFlexedItems();
        this.setFlexedItems()
    },
    prepareFlexedItems : function() {
        var a = this.getLayoutItems(), d = a.length, c, b;
        for (b = 0; b < d; b++) {
            c = a[b];
            if (c.flex != undefined) {
                c.el.setStyle("position", "absolute");
                c.boxEl = this.createBoxEl(c)
            } else {
                c.doComponentLayout()
            }
        }
    },
    setFlexedItems : function() {
        var a = this.getLayoutItems(), d = a.length, c, b;
        for (b = 0; b < d; b++) {
            c = a[b];
            if (c.flex != undefined) {
                c.boxSize = c.boxEl.getSize()
            }
        }
        for (b = 0; b < d; b++) {
            c = a[b];
            if (c.flex != undefined) {
                c.el.setStyle("position", "");
                if (this.align == "stretch") {
                    c.setSize(c.boxSize)
                } else {
                    if (this.orientation == "horizontal") {
                        c.setWidth(c.boxSize.width)
                    } else {
                        c.setHeight(c.boxSize.height)
                    }
                }
                c.boxEl.remove();
                delete c.boxEl;
                delete c.boxSize
            }
        }
    },
    getTarget : function() {
        var a = this.owner, b = this.innerCt;
        if (!b) {
            if (a.scrollEl) {
                b = a.scrollEl.addCls(this.innerCls)
            } else {
                b = a.getTargetEl().createChild({
                    cls : this.innerCls
                })
            }
            this.innerCt = b
        }
        return b
    },
    createBoxEl : function(b) {
        var a = b.el;
        return a.insertSibling({
            style : "margin-top: " + a.getMargin("tb") + "px; margin-left: "
                    + a.getMargin("lr") + "px; -webkit-box-flex: " + b.flex
        })
    }
});
Ext.layout.HBoxLayout = Ext.extend(Ext.layout.BoxLayout, {
    orientation : "horizontal"
});
Ext.regLayout("hbox", Ext.layout.HBoxLayout);
Ext.layout.VBoxLayout = Ext.extend(Ext.layout.BoxLayout, {
    orientation : "vertical"
});
Ext.regLayout("vbox", Ext.layout.VBoxLayout);
Ext.plugins.ListPagingPlugin = Ext.extend(Ext.util.Observable, {
    autoPaging : false,
    loadMoreText : "Load More...",
    init : function(a) {
        this.list = a;
        a.onBeforeLoad = Ext.util.Functions.createInterceptor(a.onBeforeLoad,
                this.onBeforeLoad, this);
        this.mon(a, "update", this.onListUpdate, this)
    },
    onListUpdate : function() {
        if (!this.rendered) {
            this.render()
        }
        this.el.appendTo(this.list.getTargetEl());
        if (!this.autoPaging) {
            this.el.removeCls("x-loading")
        }
        this.loading = false
    },
    render : function() {
        var b = this.list, c = b.getTargetEl(), a = "";
        if (!this.autoPaging) {
            a += '<div class="x-list-paging-msg">' + this.loadMoreText
                    + "</div>"
        }
        this.el = c.createChild({
            cls : "x-list-paging" + (this.autoPaging ? " x-loading" : ""),
            html : a + Ext.LoadingSpinner
        });
        if (this.autoPaging) {
            this.mon(c.getScrollParent(), "scrollend", this.onScrollEnd, this)
        } else {
            this.mon(this.el, "tap", this.onPagingTap, this)
        }
        this.rendered = true
    },
    onBeforeLoad : function() {
        if (this.loading && this.list.store.getCount() > 0) {
            this.list.loadMask.disable();
            return false
        }
    },
    onPagingTap : function(a) {
        if (!this.loading) {
            this.loading = true;
            this.list.store.nextPage();
            this.el.addCls("x-loading")
        }
    },
    onScrollEnd : function(a, b) {
        if (b.y >= Math.abs(a.offsetBoundary.top)) {
            this.loading = true;
            this.list.store.nextPage()
        }
    }
});
Ext.preg("listpaging", Ext.plugins.ListPagingPlugin);
Ext.plugins.PullRefreshPlugin = Ext
        .extend(
                Ext.util.Observable,
                {
                    pullRefreshText : "Pull down to refresh...",
                    releaseRefreshText : "Release to refresh...",
                    loadingText : "Loading...",
                    snappingAnimationDuration : 150,
                    refreshFn : null,
                    pullTpl : new Ext.XTemplate(
                            '<div class="x-list-pullrefresh">',
                            '<div class="x-list-pullrefresh-arrow"></div>',
                            Ext.LoadingSpinner,
                            '<div class="x-list-pullrefresh-wrap">',
                            '<h3 class="x-list-pullrefresh-message">{message}</h3>',
                            '<div class="x-list-pullrefresh-updated">Last Updated: <span>{lastUpdated:date("m/d/Y h:iA")}</span></div>',
                            "</div>", "</div>"),
                    isRefreshing : false,
                    isLoading : false,
                    currentViewState : "",
                    init : function(a) {
                        this.list = a;
                        this.lastUpdated = new Date();
                        a.on("update", this.onListUpdate, this);
                        a.onBeforeLoad = Ext.util.Functions.createInterceptor(
                                a.onBeforeLoad, this.onBeforeLoad, this)
                    },
                    onListUpdate : function() {
                        if (!this.rendered) {
                            this.render()
                        }
                        this.list.getTargetEl().insertFirst(this.el);
                        if (!this.refreshFn) {
                            this.onLoadComplete.call(this)
                        }
                    },
                    render : function() {
                        var b = this.list, c = b.getTargetEl(), a = c
                                .getScrollParent();
                        if (!this.pullTpl.isTemplate) {
                            this.pullTpl = new Ext.XTemplate(this.pullTpl)
                        }
                        this.el = this.pullTpl.insertFirst(c, {
                            message : this.pullRefreshText,
                            lastUpdated : this.lastUpdated
                        }, true);
                        this.messageEl = this.el
                                .down(".x-list-pullrefresh-message");
                        this.updatedEl = this.el
                                .down(".x-list-pullrefresh-updated > span");
                        this.pullHeight = this.el.getHeight();
                        this.scroller = a;
                        a.on("bouncestart", this.onBounceStart, this);
                        a.on("offsetchange", this.onOffsetChange, this);
                        a.on("bounceend", this.onBounceEnd, this);
                        a.on("offsetboundaryupdate",
                                this.onOffsetBoundaryUpdate, this);
                        this.rendered = true
                    },
                    onOffsetBoundaryUpdate : function(a, b) {
                        if (this.isRefreshing) {
                            b.bottom += this.pullHeight
                        }
                    },
                    onBounceStart : function(a, b) {
                        if (b.axis === "y") {
                            if (!this.isRefreshing
                                    && a.offset.y > this.pullHeight) {
                                this.isRefreshing = true;
                                this
                                        .onOffsetBoundaryUpdate(a,
                                                a.offsetBoundary)
                            }
                        }
                    },
                    onBounceEnd : function(a, b) {
                        if (b.axis === "y") {
                            if (this.isRefreshing) {
                                this.isRefreshing = false;
                                this.setViewState("loading");
                                this.isLoading = true;
                                if (this.refreshFn) {
                                    this.refreshFn.call(this,
                                            this.onLoadComplete, this)
                                } else {
                                    this.list.getStore().load()
                                }
                            }
                        }
                    },
                    onOffsetChange : function(a, b) {
                        if (b.y > 0 && !this.isRefreshing && !this.isLoading) {
                            if (b.y > this.pullHeight) {
                                this.setViewState("release")
                            } else {
                                this.setViewState("pull")
                            }
                        }
                    },
                    setViewState : function(a) {
                        if (a === this.currentViewState) {
                            return this
                        }
                        this.currentViewState = a;
                        switch (a) {
                        case "pull":
                            this.messageEl.setHTML(this.pullRefreshText);
                            this.el.removeCls([ "x-list-pullrefresh-release",
                                    "x-list-pullrefresh-loading" ]);
                            break;
                        case "release":
                            this.messageEl.setHTML(this.releaseRefreshText);
                            this.el.addCls("x-list-pullrefresh-release");
                            break;
                        case "loading":
                            this.messageEl.setHTML(this.loadingText);
                            this.el.addCls("x-list-pullrefresh-loading");
                            break
                        }
                        return this
                    },
                    onBeforeLoad : function() {
                        if (this.isLoading && this.list.store.getCount() > 0) {
                            this.list.loadMask.disable();
                            return false
                        }
                    },
                    onLoadComplete : function() {
                        var a = this;
                        if (this.isLoading) {
                            this.isLoading = false;
                            this.lastUpdated = new Date();
                            this.setViewState("pull");
                            this.updatedEl.setHTML(Ext.util.Format.date(
                                    this.lastUpdated, "m/d/Y h:iA"));
                            setTimeout(
                                    function() {
                                        a.scroller
                                                .updateBoundary(a.snappingAnimationDuration)
                                    }, 100)
                        }
                    }
                });
Ext.preg("pullrefresh", Ext.plugins.PullRefreshPlugin);